设计模式（五）建造者模式

引子

首先，思考为啥叫建造者？造东西吗？造车造船造楼房，都可以叫建造。由字面意思可以看出，建造者就是你要什么，我给你造什么，充分满足客户需求，客户第一嘛！我们可以自立为导演，客户说让造什么，咱就自己导演一个什么，总之，给客户搞出来就行了。

先来看官方定义（最为难懂）

Builder Pattern（建造者模式）：也叫做生成器模式，定义如下：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

看类图，还是能直接点：

 下来进行一个场景模拟演练：

Product产品类：通常是实现了模板方法模式

public class BenzModel extends CarModel {
    @Override
    protected void start() {
        System.out.println("奔驰开了！");
    }

    @Override
    protected void stop() {
        System.out.println("奔驰停了！");
    }

    @Override
    protected void alarm() {
        System.out.println("奔驰咚咚~");
    }

    @Override
    protected void engineBoom() {
        System.out.println("奔驰BOOM!");
    }
}

public class TeslaModel extends CarModel {
    @Override
    protected void start() {
        System.out.println("特斯拉跑了!");
    }

    @Override
    protected void stop() {
        System.out.println("特斯拉停了！");
    }

    @Override
    protected void alarm() {
        System.out.println("特斯拉哔哔~");
    }

    @Override
    protected void engineBoom() {
        System.out.println("特斯拉BOOM!");
    }
}

汽车模型抽象类：规定产品抽象方法

public abstract class CarModel {
    private ArrayList<String> sequence = new ArrayList<>();

    protected abstract void start();

    protected abstract void stop();

    protected abstract void alarm();

    protected abstract void engineBoom();

    final public void run() {
        for (int i = 0; i < sequence.size(); i++) {
            String actionName = this.sequence.get(i);
            if (actionName.equalsIgnoreCase("start")) {
                this.start();
            } else if (actionName.equalsIgnoreCase("stop")) {
                this.stop();
            } else if (actionName.equalsIgnoreCase("alarm")) {
                this.alarm();
            } else if (actionName.equalsIgnoreCase("engineBoom")) {
                this.engineBoom();
            }
        }
    }

    final public void setSequence(ArrayList<String> sequence) {
        this.sequence = sequence;
    }
}

Builder抽象建造者：规范产品的组建，一般由子类实现

public abstract class CarBuilder {
    //创建一个模型，要什么顺序，给你什么顺序
    public abstract void setSquence(ArrayList<String> sequence);

    //设置完毕顺序后，就可以直接拿到这个车辆模型
    public abstract CarModel getCarModel();
}

ConcreteBuilder具体建造者：实现抽象类定义的所有方法

public class BenzBuilder extends CarBuilder {
    private BenzModel benz = new BenzModel();
    @Override
    public void setSquence(ArrayList<String> sequence) {
        this.benz.setSequence(sequence);
    }

    @Override
    public CarModel getCarModel() {
        return this.benz;
    }
}

public class TeslaBuilder extends CarBuilder {
    private TeslaModel tesla = new TeslaModel();
    @Override
    public void setSquence(ArrayList<String> sequence) {
        this.tesla.setSequence(sequence);
    }

    @Override
    public CarModel getCarModel() {
        return this.tesla;
    }
}

Director导演类：负责安排已有模块的顺序，告诉Builder开始建造

public class Director {
    private ArrayList<String> sequence = new ArrayList<>();
    private BenzBuilder benzBuilder = new BenzBuilder();
    private TeslaBuilder teslaBuilder = new TeslaBuilder();

    public BenzModel getABenzModel() {
        //清理场景，必须！
        this.sequence.clear();
        this.sequence.add("start");
        this.sequence.add("stop");
        this.benzBuilder.setSquence(sequence);
        return (BenzModel) this.benzBuilder.getCarModel();
    }

    public BenzModel getBBenzModle() {
        //清理场景，必须！
        this.sequence.clear();
        this.sequence.add("start");
        this.sequence.add("alarm");
        this.benzBuilder.setSquence(sequence);
        return (BenzModel) this.benzBuilder.getCarModel();
    }

    public TeslaModel getATeslaModle() {
        //清理场景，必须！
        this.sequence.clear();
        this.sequence.add("stop");
        this.sequence.add("engineBoom");
        this.teslaBuilder.setSquence(sequence);
        return (TeslaModel) this.teslaBuilder.getCarModel();
    }
}

结果

public class Client {
    public static void main(String[] args) {
        Director director = new Director();

        director.getABenzModel().run();
        director.getBBenzModle().run();
        director.getATeslaModle().run();
    }
}

建造者模式的优点

• 封装性，不需要关心每一个具体的模型内部是如何实现的，产生的对象类型就是CarModel。
• 建造者独立，容易扩展。
• 便于控制细节风险。

建造者使用场景

• 相同的方法，不同的执行顺序，产生不同的事件结果时。
• 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。
• 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能。
• 在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到时。 

与工厂方法模式最大不同

建造者模式关注的是零件类型和装配工艺顺序。