设计模式之Build模式——对象创建型

意图

• 将一个复杂对象的构造与它的表示分离，使得同样的构造过程可以创建不同的表示。
• 当构造过程必须允许被构造的对象有不同的表示时

适用性

当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

结构

Builder模式结构图

参与者

• Builder
  — 为创建一个 Product 对象的各个部件指定抽象接口
• ConcreteBuilder，实现 Builder 的接口以构造和装配该产品的各个部件
  — 实现 Builder 的接口以构造和装配该产品的各个部件
  — 定义并明确它创建的表示
  — 提供一个检索产品的接口
• Director
  — 构造一个使用 Builder 接口的对象
• Product
  — 表示被构造的复杂对象。ConcreteBuilder 创建该产品的内部表示并定义它的装配过程。
  — 包含定义组成部件的类，包含将这些部件装配成最终产品的接口

实现

比如我们要画三条杠，那么我们的 Product 类——产品类，由多个部件组成

    public class Product {
    
        List<String> parts = new ArrayList<>();
    
        public void add(String part){  //添加产品部件
            parts.add(part);
        }
    
        public void showProduct(){ //展示产品
            System.out.println(parts.toString());
        }
    
    }

Buidler，抽象构造者，确定产品有 FirstLine 、SecondLine 和 ThirdLine 构成。

    public interface Builder {
        void paintFirstLine();
        void paintSecondLine();
        void paintThirdLine();
    }

ConcreteBuilderA 类——具体构造者类

    public class ConcreteBuilderA implements Builder{
    
        private Product product = new Product();
    
        @Override
        public void paintFirstLine() {
            product.add("red");
        }
    
        @Override
        public void paintSecondLine() {
            product.add("green");
        }
    
        @Override
        public void paintThirdLine() {
            product.add("blue");
        }
    
        public Product getResult(){
            return product;
        }
    }

ConcreteBuilderB 类——具体构造者类

    public class ConcreteBuilderB implements Builder{
    
        private Product product = new Product();
    
        @Override
        public void paintFirstLine() {
            product.add("black");
        }
    
        @Override
        public void paintSecondLine() {
            product.add("white");
        }
    
        @Override
        public void paintThirdLine() {
            product.add("grey");
        }
    
        public Product getResult(){
            return product;
        }
    }

Directot 类——指挥者类，一步步构造一个复杂对象

    public class Director {
    
        public void build(Builder builder){
            //画第一条线
            builder.paintFirstLine();
            //画第二条线
            builder.paintSecondLine();
            //画第三条
            builder.paintThirdLine();
        }
    }

Client 客户端调用，客户端不需要知道具体的构造过程

public static void main(String[] args) {

    Director director = new Director();

    //构造出具体的产品A
    Builder builder1 = new ConcreteBuilderA();
    director.build(builder1);
    Product product1 = ((ConcreteBuilderA) builder1).getResult();
    product1.showProduct();

    ////构造出具体的产品B
    Builder builder2 = new ConcreteBuilderB();
    director.build(builder2);
    Product product2 = ((ConcreteBuilderB) builder2).getResult();
    product2.showProduct();
}

如果我们只需要一个具体的产品，那么为了提高内聚性，Builder就作为实际产品的静态内部类来实现
此时，Product,Director, Builder是在一个类文件中。我们还是画三条杆，代码如下：

public class Product {

    private String firstLine;
    private String secondLine;
    private String thirdLine;



    public Product(Builder builder){ //Director
        this.firstLine = builder.firstLine;
        this.secondLine = builder.secondLine;
        this.thirdLine = builder.thirdLine;
    }

    @Override
    public String toString() {
        return "Product{" +
                "firstLine='" + firstLine + '\'' +
                ", secondLine='" + secondLine + '\'' +
                ", thirdLine='" + thirdLine + '\'' +
                '}';
    }

    public static class Builder{

        //默认为白色线
        private String firstLine = "white";
        private String secondLine = "white";
        private String thirdLine = "white";

        public Builder paintFirstLine(String firstLine){
            this.firstLine = firstLine;
            return this;
        }



        public Builder paintSecondLine(String secondLine){
            this.secondLine = secondLine;
            return this;
        }

        public Builder paintThirdLine(String thirdLine){
            this.thirdLine = thirdLine;
            return this;
        }

        public Product build(){ //返回产品
            return new Product(this);
        }
    }

    public static void main(String[] args) {
        Product product = new Product.Builder().paintFirstLine("red")
                .paintSecondLine("green")
                .paintThirdLine("blue").build();
        System.out.println(product);
    }
    
}

这样实现整个类就是一个具体产品，但是无论客户端 new 多少次，最终只会得到一个产品，改变的仅仅是属性的值。如果客户端同时需要多个不同的产品，我们就又要创建一个类似的类，不要忘记此时Product,Director, Builder是耦合在一个类文件中的。这时，我们就应该把它们解耦出去。

参考资料

[1] Erich Gamma，Richard Helm，Ralph Johnson，John Vlissides. 设计模式：可复用面向对象软件的基础[M]. 李英军等译.北京：机械工业出版社，2009.
[2] 程杰. 大话设计模式[M]. 北京 : 清华大学出版社 , 2007.