设计模式之建造者详细解读

设计模式之建造者

**概念：**建造者模式是一种创建型设计模式，也叫生成器模式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
**解释：**就是将复杂对象的创建过程拆分成多个简单对象的创建过程，并将这些简单对象组合起来构建出复杂对象。

在一个建造者模式中，通常需要一下角色：
Builder（抽象建造者）：它为创建一个产品Product对象的各个部件指定抽象接口，在该接口中一般声明两类方法，一类方法是buildPartX()，它们用于创建复杂对象的各个部件；另一类方法是getResult()，它们用于返回复杂对象。Builder既可以是抽象类，也可以是接口。
ConcreteBuilder（具体建造者）：它实现了Builder接口，实现各个部件的具体构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象。
Product（产品角色）：它是被构建的复杂对象，包含多个组成部件。
Director（指挥者）：它负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其construct()方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。

样例：
我们以建造一辆小米su7汽车来举例，众所周知，一辆汽车建造起来是很复杂的，肯定要有电池，要有车身，要有人工智能等等等等，假如我现在需要一辆搭载了小爱同学且车身颜色是蓝色的小米su7,然后需要一辆搭载了小艺同学且车身颜色为红色的华为m7汽车

Product（产品角色）

public class Car {

    private String carBattery;

    private String carBody;

    private String carAi;

    private String carPrice;

    public void setCarBattery(String carBattery) {
        this.carBattery = carBattery;
    }

    public void setCarBody(String carBody) {
        this.carBody = carBody;
    }

    public void setCarAi(String carAi) {
        this.carAi = carAi;
    }

    public void setCarPrice(String carPrice) {
        this.carPrice = carPrice;
    }

    @Override
    public String toString() {
        return "Car{" +
                "carBattery='" + carBattery + '\'' +
                ", carBody='" + carBody + '\'' +
                ", carAi='" + carAi + '\'' +
                ", carPrice='" + carPrice + '\'' +
                '}';
    }

}

抽象建造者（Builder）

abstract class Builder {

    Car car = new Car();
    public Car builder() {
        return car;
    }

    //建造汽车电池
    abstract void builderCarBattery();
    //建造汽车车身
    abstract void builderCarBody();
    //建造汽车人工智能
    abstract void builderCarAi();
    //建造汽车颜色
    abstract void builderColor();
    
}

具体构建者（ConcreteBuilder） 以小米su7的建造为例

public class XiaoMiSu7 extends Builder{

    @Override
    void builderCarBattery() {
        car.setCarBattery("比亚迪");
    }

    @Override
    void builderCarBody() {
        car.setCarBody("保时捷同款");
    }

    @Override
    void builderCarAi() {
        car.setCarAi("小爱同学");
    }

    @Override
    void builderColor() {
        car.setColor("蓝");
    }
}

具体构建者（ConcreteBuilder） 以华为m7的建造为例

public class HuaWeiM9 extends Builder{

    @Override
    void builderCarBattery() {
        car.setCarBattery("宁德时代");
    }

    @Override
    void builderCarBody() {
        car.setCarBody("一体化");
    }

    @Override
    void builderCarAi() {
        car.setCarAi("小艺");
    }

    @Override
    void builderColor() {
        car.setColor("红");
    }
}

Director（指挥者）

/**
 * @author admin
 */
public class Director {

    Builder  builder;

    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    Car createCar1(){
       builder.builderCarBattery();
       builder.builderCarAi();
       return builder.builder();
    }

    Car createCar2(){
        builder.builderCarBattery();
        builder.builderColor();
        return builder.builder();
    }
}

测试类

public class Main {
    public static void main(String[] args) {
        //指挥者
        Director director = new Director();
        //小米su7实例
        XiaoMiSu7  xiaomi = new XiaoMiSu7();
        HuaWeiM9 huawei = new HuaWeiM9();
        director.setBuilder(xiaomi);
        System.out.println(director.createCar1().toString());
        director.setBuilder(huawei);
        System.out.println(director.createCar1().toString());
    }
}

通过观察可以发现，根据不同的需求，建造者模式可以构造出不同的车对象。每个车的构建过程都由不同的建造者实现，在构建过程中可定制相应的属性。最终，因为车的构建过程和表示分离，所以同样的构建过程可以创建出不同的表示。

与抽象工厂模式的区别：

    抽象工厂模式强调的是产品族的创建，即相关的产品一起被创建出来，而建造者模式强调的是一个复杂对象的创建，即它的各个部分逐步被创建出来。