建造者设计模式(Builder Pattern)

将一个复杂对象的创建过程分离出来，利用接口编程，同样的创建逻辑可以构建出不同的对象实例。

假设我们有一组复杂对象群，这组对象的构建过程都足够复杂而且其创建的整体逻辑是相似的。那么我们就可以使用这种设计模式。

丢一个别人已经画好的 UML 图

image

模式结构

主要包含四个模块

• Builder：建造者接口，构建对象时各种组件创建过程的整体抽象。不同的建造者实现类可以用来创建各种不同的实例，但是他们的总体上创建逻辑是类似的，将这些创建方法抽象出来，放到接口里面来。
• ConcreteBuilder：建造者实现类，实现建造者接口，负责实现某一个对象各个组件的创建和组装逻辑。
• Director：指挥者，构建一个 builder 对象，在这个模块里，依据具体的 builder 实例创建出客户端所需要的实例并返回给客户端。以此将复杂的创建逻辑与客户端隔离开，客户端只需要使用 Director 来创建出具体的对象而不需要关心实现的逻辑。另外一个作用是：builder 中已经有了对象各个组件的拼装逻辑，在 Director 中我们可以按照自己的逻辑来组装完成一个对象，这个 组装的顺序 是比较重要的，在这里我们可以按照自己的意愿来完成拼装逻辑。
• Product：产品，最终所需要的对象。

代码示例

• Product

/**
 * @author gaopeng@doctorwork.com
 * @description
 * @date 2018-06-13 20:25
 **/
public class Car {

    private Wheel wheel;

    private Engine engine;

    private SteeringWheel steeringWheel;

    public Car() {
        System.out.println("finally I get a car!");
    }

    Car(Wheel wheel, Engine engine, SteeringWheel steeringWheel) {
        this.wheel = wheel;
        this.engine = engine;
        this.steeringWheel = steeringWheel;
    }

    public Wheel getWheel() {
        return wheel;
    }

    public void setWheel(Wheel wheel) {
        this.wheel = wheel;
    }

    public Engine getEngine() {
        return engine;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public SteeringWheel getSteeringWheel() {
        return steeringWheel;
    }

    public void setSteeringWheel(SteeringWheel steeringWheel) {
        this.steeringWheel = steeringWheel;
    }
}

• Procuct 的组件

public class Wheel {

    public Wheel() {
        System.out.println("get a wheel!");
    }
}

public class Engine {

    public Engine() {
        System.out.println("get a engine!");
    }
}

public class SteeringWheel {

    public SteeringWheel() {
        System.out.println("get a steeringWheel!");
    }
}

• Builder

public interface Builder {

    void buildWheel();

    void buildEngine();

    void buildSteeringWheel();

    Car getCar();
}
=================================
/**
 * @author gaopeng@doctorwork.com
 * @description 继承建造接口的实际建造者类，提供了创建完整对象所需要的各种零件
 * @date 2018-06-13 20:30
 **/
public class ConcreteBuilder implements Builder{

    private Car car = new Car();

    public void buildWheel() {
        car.setWheel(new Wheel());
    }

    public void buildEngine() {
        car.setEngine(new Engine());
    }

    public void buildSteeringWheel() {
        car.setSteeringWheel(new SteeringWheel());
    }

    public Car getCar() {
        return car;
    }
}

• Director

/**
 * @author gaopeng@doctorwork.com
 * @description “导演”，负责具体的对象拼装，并可以在这里组织具体的产品构建流程
 * @date 2018-06-13 20:36
 **/
public class Director {

    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    /**
     * 在这个构建方法中，我们按一定的次序为 car 对象组装零件。这个顺序在某些场景是很重要的。因此这也是建设者模式很重要的一个优点。
     *
     * @return
     */
    public Car constructCar() {
        builder.buildEngine();
        builder.buildWheel();
        builder.buildSteeringWheel();
        return builder.getCar();
    }

}

• 测试demo

public class Main {

    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();

        Director director = new Director(builder);

        Car car = director.constructCar();
    }
}

优缺点

• 优点
  • 可以将复杂对象的构建过程分解出来，创建的逻辑经过梳理会变得更清晰。
  • 将创建过程与客户端用户隔离开，用户也不需要去梳理这些创建逻辑了，只要创建 director 和 builder 就好了。具体的细节与实现依赖抽象
  • 因为有完成的接口体系，所以不同的对象可以有各自的实现。不同的对象之间相互独立。
• 缺点
  • 建造者模式适合一组有一定相似度的对象群。如果复杂对象之间差异较大，就无法抽象出一个高可用性的接口/抽象类。
  • 如果产品内部十分复杂，可能会导致我们创建出很多的衍生类和建造者，最终让这个系统变得繁杂而庞大。

应用示例

在 Spring 的 bean 体系中，beanDefinition 实例就是通过 建造者设计模式 创建出来的。

在这个 builder 中，beanDefinition 创建的流程被一步步分解，各个子方法分别负责为其添加一个个的组件。

    /**
     * Set the name of the parent definition of this bean definition.
     */
    public BeanDefinitionBuilder setParentName(String parentName) {
        this.beanDefinition.setParentName(parentName);
        return this;
    }
    
    /**
     * Set the name of a static factory method to use for this definition,
     * to be called on this bean's class.
     */
    public BeanDefinitionBuilder setFactoryMethod(String factoryMethod) {
        this.beanDefinition.setFactoryMethodName(factoryMethod);
        return this;
    }
    
    /**
     * Set the name of a non-static factory method to use for this definition,
     * including the bean name of the factory instance to call the method on.
     * @since 4.3.6
     */
    public BeanDefinitionBuilder setFactoryMethodOnBean(String factoryMethod, String factoryBean) {
        this.beanDefinition.setFactoryMethodName(factoryMethod);
        this.beanDefinition.setFactoryBeanName(factoryBean);
        return this;
    }
    /**
     * Add an indexed constructor arg value. The current index is tracked internally
     * and all additions are at the present point.
     */
    public BeanDefinitionBuilder addConstructorArgValue(Object value) {
        this.beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(
                this.constructorArgIndex++, value);
        return this;
    }

    ...