4. 建造者模式（Builder Pattern)

定义

• 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
• 用户只需指定需要建造的类型就可以得到它们，建造过程及细节不需要指定

类型

• 创建型

适用场景

• 如果一个对象有非常复杂的内部结构（很多属性）
• 想把复杂对象的创建和使用分离

优点

• 封装性好，创建和使用分离
• 扩展性好、建造类之间独立、一定程度上解耦

缺点

• 产生多余的Builder对象
• 产品内部发生变化，建造者都要修改，成本较大

建造者模式 VS 工厂模式

1. 建造者模式更注重方法的调用顺序，工厂模式注重创建产品
2. 创建对象的粒度不同，建造者模式可以创建一些复杂的产品，由各种复杂的部件组成，工厂模式创建出来的都是一个样子
3. 关注点不同，工厂模式注重的只要把产品创建出来就ok了，而建造者模式不止要创建产品，还需要知道是由那些部件组成的
4. 在某些业务场景，比如说一定的顺序决定产出的产品不一样的话，那么也要进行顺序调整，工厂模式则不关心顺序

组成

1. 建造者（Builder）：为创建一个产品对象的各个部件指定的抽象接口。
2. 具体建造者（ConcreteBuilder）：实现Builder的接口，构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。
3. 指挥者（Director）：指挥并构造一个使用Builder接口的对象。
4. 产品（Product）：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

代码示例

一般实现

1. 创建产品（Product）
   一个具体的产品对象，其中包含各个属性

/**
 * 汽车
 */
public class Car {

    //颜色
    private String color;
    //引擎
    private String engine;
    //车轮
    private String vehicleWheel;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getEngine() {
        return engine;
    }

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

    public String getVehicleWheel() {
        return vehicleWheel;
    }

    public void setVehicleWheel(String vehicleWheel) {
        this.vehicleWheel = vehicleWheel;
    }

    @Override
    public String toString() {
        return "Car{" +
                "color='" + color + '\'' +
                ", engine='" + engine + '\'' +
                ", vehicleWheel='" + vehicleWheel + '\'' +
                '}';
    }
}

2. 创建抽象建造者（Builder）
   定义产品的创建方法和返回方法

/**
 * 建造者抽象类
 */
public abstract class Builder {
    
    public abstract void builderColor(String color);
    public abstract void builderEngine(String engine);
    public abstract void builderVehicleWheel(String vehicleWheel);

    
    public abstract Car makeCar();

}

3. 创建具体建造者（ConcreteBuilder）
   实现抽象接口，构建和装配各个部件

/**
 * 具体建造者
 */
public class ConcreteBuilder extends Builder{
    private Car car = new Car();

    @Override
    public void builderColor(String color) {
        car.setColor(color);
    }

    @Override
    public void builderEngine(String engine) {
        car.setEngine(engine);
    }

    @Override
    public void builderVehicleWheel(String vehicleWheel) {
        car.setVehicleWheel(vehicleWheel);
    }

    @Override
    public Car makeCar() {
        return this.car;
    }
}

4. 创建指挥者（Director）
   作用主要有两点。一是：隔离了应用层与对象的生产过程，二是：负责控制产品对象的生产过程。

/**
 * 指挥者类
 * 针对建造者抽象类编程
 */
public class Director {

    private Builder builder;
    //1.构造器注入builder对象
    public Director(Builder builder){
        this.builder = builder;
    }
    //2.Set方法注入builder对象
    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    //通过抽象方法建造产品
    public Car makeCar(String color, String engine, String vehicleWheel){
        builder.builderColor(color);
        builder.builderEngine(engine);
        builder.builderVehicleWheel(vehicleWheel);
        return builder.makeCar();
    }
}

5. 客户端调用
   客户端只要知道具体的建造者，就可以通过调用指挥者类的相关方法，返回一个完整的产品

public class Client {
    public static void main(String[] args) {
        Director director = new Director(new ConcreteBuilder());
        Car car = director.makeCar("黑色","12缸发动机","22寸大轮毂");
        System.out.println(car.toString());
    }
}

执行结果

Car{color='黑色', engine='12缸发动机', vehicleWheel='22寸大轮毂'}

当前类图

当前有一个问题，假设产品有很多并且很复杂的参数，当我director.makeCar（）的时候就很容出错，假设有20个参数那鬼知道这些参数在什么位置，所有我们要进行一下改进

改进

解决方案，用链式调用的方法，在我们实际的开发过程也是比较常见。

1. 在产品中添加静态内部类，这个静态内部类就是建造者

/**
 * 汽车
 */
public class Car {
    //颜色
    private String color;
    //引擎
    private String engine;
    //车轮
    private String vehicleWheel;

    //创建一个参数是我们当前静态内部类对象的构造器
    public Car(CarBuilder carBuilder) {
        //属性赋值
        this.color = carBuilder.color;
        this.engine = carBuilder.engine;
        this.vehicleWheel = carBuilder.vehicleWheel;
    }

    @Override
    public String toString() {
        return "Car{" +
                "color='" + color + '\'' +
                ", engine='" + engine + '\'' +
                ", vehicleWheel='" + vehicleWheel + '\'' +
                '}';
    }


    /**
     * 汽车建造者
     * 1.与具体产品有相同属性
     * 2.进行属性赋值，并返回当前对象（因为要进行链式调用，当进行一个赋值方法后，因为return的是当地对象，所有还可以调用其他的赋值方法）
     * 3.创建具体产品builder()
     */
    public static class CarBuilder{
        //颜色
        private String color;
        //引擎
        private String engine;
        //车轮
        private String vehicleWheel;

        public CarBuilder builderColor(String color) {
            this.color = color;
            return this;
        }

        public CarBuilder builderEngine(String engine) {
            this.engine = engine;
            return this;
        }

        public CarBuilder builderVehicleWheel(String vehicleWheel) {
            this.vehicleWheel = vehicleWheel;
            return this;
        }

        public Car builder(){
            return new Car(this);
        }
    }
}

2. 客户端调用
   应用层只需要控制，和那个建造这进行交互，然后设置具体的属性，最后调用builder方法，就可以得到一个完整的产品对象

public class Client {
    public static void main(String[] args) {
        Car car = new Car.CarBuilder()
                            .builderColor("黑色")
                            .builderEngine("12缸发动机")
                            .builderVehicleWheel("22寸大轮毂")
                            .builder();
        System.out.println(car.toString());
    }
}

执行结果：
与原来的结果一致

Car{color='黑色', engine='12缸发动机', vehicleWheel='22寸大轮毂'}

这种方式的类图就很简单了

这种演进版本的好处：一方面可以按需调用，另一方面可以链式调用比较方便，看起来更优雅一些，注重的一点就是出错的几率会小一些。
.