建造者模式

建造者模式：也叫作生成器模式，将一个复杂对象的创建与它的表示分离，使得同样的构建过程可以创建不同的表示（Separate the construction of a complex object from its representation so that the same construction process can create different representations）。
建造者模式中有4个角色，其通用类图如下：

Product产品类：通常是实现了模板方法模式，也就是有模板方法和基本方法。通常以抽象类和具体类（类图中省略了抽象类）。参考详细例子中的BenzModel和BMWModel类。
Builder抽象建造者：规范产品的组建，定义抽象方法，一般由具体的构建子类实现。详细例子中的CarBuilder就属于抽象建造者。
ConcreteBuilder具体建造者：实现抽象类定义的所有方法，并且返回一个组建好的对象。参见详细例子中的BenBuilder和BMWBuilder。
Director导演类：负责安排已有模板的顺序，然后传递给Builder开始建造。
建造者的通用源码如下：

public class Product {
    private void doSomething(){
        //产品的业务处理
    }
}

public abstract class Builder {
    //设置产品的不同部分，以获得不同的产品
    public abstract void setPart();
    //建造产品
    public abstract Product buildProduct();
}

public class ConcreteBuilder extends Builder{
    private Product product = new Product();
    @Override
    public void setPart() {
        // TODO Auto-generated method stub
        //产品类内部的逻辑处理
    }

    @Override
    public Product buildProduct() {
        // TODO Auto-generated method stub
        return product;
    }
}

public class Director {
    private Builder builder = new ConcreteBuilder();
    public Product getProduct(){
        builder.setPart();
        return builder.buildProduct();
    }
}

详细例子的通用类图和源码如下：

public abstract class CarModel {
    private ArrayList<String> sequence = new ArrayList<String>();
    protected abstract void start();
    protected abstract void alarm();
    protected abstract void stop();
    final public void run(){
        for(int i = 0; i < sequence.size(); i++){
            String actionName = sequence.get(i);
            if(actionName.equalsIgnoreCase("start")){
                this.start();
            }else if(actionName.equalsIgnoreCase("stop")){
                this.stop();
            }else if(actionName.equalsIgnoreCase("alarm")){
                this.alarm();
            }
        }
    }
    final public void setSequence(ArrayList<String> sequence){
        this.sequence = sequence;
    }
}

public class BenzModel extends CarModel{
    @Override
    protected void start() {
        // TODO Auto-generated method stub
        System.out.println("奔驰车启动");
    }
    @Override
    protected void alarm() {
        // TODO Auto-generated method stub
        System.out.println("奔驰车鸣笛");
    }
    @Override
    protected void stop() {
        // TODO Auto-generated method stub
        System.out.println("奔驰车停止");
    }
}

public class BMWModel extends CarModel{
    @Override
    protected void start() {
        // TODO Auto-generated method stub
        System.out.println("宝马车启动");
    }
    @Override
    protected void alarm() {
        // TODO Auto-generated method stub
        System.out.println("宝马车鸣笛");
    }
    @Override
    protected void stop() {
        // TODO Auto-generated method stub
        System.out.println("宝马车停止");
    }
}

public abstract class CarBuilder {
    protected abstract void setSequence(ArrayList<String> sequence);
    protected abstract CarModel getCarModel();
}

public class BenzBuilder extends CarBuilder{
    private BenzModel benz = new BenzModel();
    @Override
    protected void setSequence(ArrayList<String> sequence) {
        // TODO Auto-generated method stub
        benz.setSequence(sequence);
    }
    @Override
    protected CarModel getCarModel() {
        // TODO Auto-generated method stub
        return this.benz;
    }
}

public class BMWBuilder extends CarBuilder{
    private BMWModel bmw = new BMWModel();
    @Override
    protected void setSequence(ArrayList<String> sequence) {
        // TODO Auto-generated method stub
        bmw.setSequence(sequence);
    }

    @Override
    protected CarModel getCarModel() {
        // TODO Auto-generated method stub
        return this.bmw;
    }
}

public class Director {
    private ArrayList<String> sequence = new ArrayList<String>();
    private BenzBuilder benz = new BenzBuilder();
    private BMWBuilder bmw = new BMWBuilder();
    public BenzModel getBenzModel(){
        this.sequence.clear();
        this.sequence.add("start");
        this.sequence.add("stop");
        benz.setSequence(sequence);
        return (BenzModel)benz.getCarModel();
    }
    public BMWModel getBMWModel(){
        this.sequence.clear();
        this.sequence.add("start");
        this.sequence.add("alarm");
        this.sequence.add("stop");
        this.bmw.setSequence(sequence);
        return (BMWModel)this.bmw.getCarModel();
    }
}

public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Director director = new Director();
        director.getBenzModel().run();
        director.getBMWModel().run();
    }
}

View Code

建造者模式的优点
- 封装性：使用建造者模式可以使客户端不必知道产品内部组成的细节，如例子中我们不必关系每一个具体的模型内部是如何实现的，产生的对象类型就是CarModel。
- 建造者独立，容易扩展，BenzBuilder和BMWBuilder相互独立，有利于系统扩展。
- 便于控制细节风险，由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。
建造者模式的使用场景
- 相同的方法，不同的执行顺序，产生不同的事件结果，可以采用建造者模式；
- 多个部件或零件都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式；
- 产品类非常复杂，或者产品类中的顺序不同产生不同的效能，则可以使用建造者模式；
- 在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过创建者模式柔化创建过程，本身就违反了设计的最初目标。
最佳实践

本文中列举的实例，通过将建造者模式和模板方法模式进行结合，就是一个对建造者模式很好的扩展实践。

建造者模式

建造者模式

建造者模式中有4个角色，其通用类图如下：

建造者模式的优点

建造者模式的使用场景

最佳实践