设计模式-建造者模式

建造者模式也叫生成器模式。

1、定义

Separate the construction of a complex object from its representation so that the same construction process can create different representations

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

2、类图

3、角色

Product：产品类。通常是实现了模板方法模式，也就是有模板方法和基本方法。

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

ConcreteBuilder：具体构造者。实现抽象类定义的所有方法，并且返回一个组件好的对象。

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

4、例子

Product：

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

    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 < this.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;
    }


}

public class BenzModel extends CarModel {
    @Override
    protected void start() {
        System.out.println("Benz start");
    }

    @Override
    protected void stop() {
        System.out.println("Benz stop");
    }

    @Override
    protected void alarm() {
        System.out.println("Benz alarm");
    }

    @Override
    protected void engineBoom() {
        System.out.println("Benz engineBoom");
    }
}

public class BMWModel extends CarModel {
    @Override
    protected void start() {
        System.out.println("BMW start");
    }

    @Override
    protected void stop() {
        System.out.println("BMW stop");
    }

    @Override
    protected void alarm() {
        System.out.println("BMW alarm");
    }

    @Override
    protected void engineBoom() {
        System.out.println("BMW engineBoom");
    }
}

Builder：

public abstract class CarBuilder {
    public abstract void setSequence(ArrayList<String> sequence);

    public abstract CarModel getCarModel();
}

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

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

public class BMWBuilder extends CarBuilder {
    private BMWModel mBMWModel = new BMWModel();
    @Override
    public void setSequence(ArrayList<String> sequence) {
        this.mBMWModel.setSequence(sequence);
    }

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

Director：

public class Director {

    private ArrayList<String> sequence = new ArrayList<String>();
    private BenzBuilder benzBuilder = new BenzBuilder();
    private BMWBuilder bmwBuilder = new BMWBuilder();

    public BenzModel getABenzModel(){
        this.sequence.clear();
        this.sequence.add("stop");
        this.sequence.add("engineBoom");
        this.sequence.add("start");
        this.benzBuilder.setSequence(sequence);

        return (BenzModel) this.benzBuilder.getCarModel();
    }

    public BMWModel getABMWModel(){
        this.sequence.clear();
        this.sequence.add("start");
        this.sequence.add("engineBoom");
        this.sequence.add("stop");
        this.bmwBuilder.setSequence(sequence);

        return (BMWModel) this.bmwBuilder.getCarModel();
    }

}

使用：

System.out.println("-----------------------------------");

Director director = new Director();
BenzModel aBenzModel = director.getABenzModel();
aBenzModel.run();
  System.out.println("------------------------------------");

Director director1 = new Director();
BMWModel abmwModel = director1.getABMWModel();
abmwModel.run();

输出：

I/System.out: -----------------------------------
I/System.out: Benz stop
I/System.out: Benz engineBoom
I/System.out: Benz start
I/System.out: ------------------------------------
I/System.out: BMW start
I/System.out: BMW engineBoom
I/System.out: BMW stop

5、优缺点

封装性：使用建造者模式可以使客户端不必知道产品内部组成的细节，如例子中我们就不需要关 心每一个具体的模型内部是如何实现的，产生的对象类型就是CarModel。
 建造者独立，容易扩展：BenzBuilder和BMWBuilder是相互独立的，对系统的扩展非常有利。
便于控制细节风险：由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

6、使用场景

a、相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。
b、多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。
c、产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适。
d、在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过创建者模式柔化创建过程，本身已经违反设计的最初目标。

7、注意事项

建造者模式关注的是零件类型和装配工艺（顺序），这是它与工厂方法模式最大不同的地方，虽然同为创建类模式，但是注重点不同。

在使用建造者模式的时候考虑一下模板方法模式，别孤立地思考一个模式，僵化地套用一个模式会让你受害无穷！