创建型模式之Builder模式及实现

建造者（Builder）模式

GOF给出的定义为：建造者模式是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

应用场景

使用建造者模式是为了将构建复杂对象的过程和它的部件解耦。注意：是解耦过程和部件。

参与角色

建造者模式通常包括以下这几个角色： 1、Builder：给出一个抽象接口，规范建造者对于生产的产品的各个组成部分的建造。这个接口只是定一个规范，不涉及具体的建造，具体的建造让继承于它的子类（ConcreteBuilder）去实现。
2、ConcreteBuilder：实现builder接口，针对不同的商业逻辑，具体化各对象部分的建造，最后返回一个建造好的产品。
3、Director：导演，顾名思义，负责规范流程之用。在指导中不涉及产品的创建，只负责保证复杂对象各部分被创建或按某种顺序创建。
4、Product：复杂对象。

如何使用建造者模式

首先假设一个复杂对象是由多个部件组成的，Builder模式是把复杂对象的创建和部件的创建分别开来，分别用Builder类和Director类来表示。

首先,需要一个接口，它定义如何创建复杂对象的各个部件：

public interface Builder {
    //创建部件A　　比如创建汽车车轮
    void buildPartA();
    //创建部件B 比如创建汽车方向盘
    void buildPartB();
    //创建部件C 比如创建汽车发动机
    void buildPartC();
     
    /**返回最后组装成品结果 (返回最后装配好的汽车)
     * 成品的组装过程不在这里进行,而是转移到下面的Director类中进行
     * 从而实现了解耦过程和部件
     */
    Product getResult();
}

用Director构建最后的复杂对象，而在上面Builder接口中封装的是如何创建一个个部件(复杂对象是由这些部件组成的)，
也就是说Director的内容是如何将部件最后组装成成品：

public class Director {
 
    private Builder builder;
     
    public Director(Builder builder){
        this.builder=builder;
    }
     
    /** 将部件partA partB partC最后组成复杂对象 */
    public void construct(){
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}

Builder的具体实现ConcreteBuilder：
通过具体完成接口Builder来构建或装配产品的部件；
定义并明确它所要创建的是什么具体东西；
提供一个可以重新获取产品的接口。

public class ConcreteBuilder implements Builder{
     
    private Product product;
 
    @Override
    public void buildPartA() {
        /**
         * 在此创建出部件
         * 把partA传递给product
         */
        PartA partA=new PartA();
        product.setPartA(partA);
    }
 
    @Override
    public void buildPartB() {
        PartB partB=new PartB();
        product.setPartB(partB);
    }
 
    @Override
    public void buildPartC() {
        PartC partC=new PartC();
        product.setPartC(partC);
    }
 
    @Override
    public Product getResult() {
        return product;
    }
     
 
}

复杂对象产品：

public class Product {
 
    private PartA partA;
    private PartB partB;
    private PartC partC;
     
    public PartA getPartA() {
        return partA;
    }
    public void setPartA(PartA partA) {
        this.partA = partA;
    }
    public PartB getPartB() {
        return partB;
    }
    public void setPartB(PartB partB) {
        this.partB = partB;
    }
    public PartC getPartC() {
        return partC;
    }
    public void setPartC(PartC partC) {
        this.partC = partC;
    }
 
}

复杂对象的部件：

public class PartA {
 
}

public class PartB {
 
}

public class PartC {
 
}

如何应用：

public class Test {
 
    public static void main(){
         
        Builder builder=new ConcreteBuilder();
        Director director=new Director(builder);
        director.construct();
        Product product = builder.getResult();
         
         
    }
}

使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。
其次，建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。

(图片转自网络等)