设计模式——建造者模式

定义

---

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

使用场景

---

• 相同方法，不同执行顺序，产生不同事件结果。
• 多个部件或零件可以装配到一个对象中，对产生的运行结果不相同。
• 产品类复杂，产品类调用顺序不同产生不同效能。

UML

---

示例

---

产品类

public class Product {
    private String param1;
    private String param2;
    private String param3;

    public String getParam1() {
        return param1;
    }

    public void setParam1(String param1) {
        this.param1 = param1;
    }

    public String getParam2() {
        return param2;
    }

    public void setParam2(String param2) {
        this.param2 = param2;
    }

    public String getParam3() {
        return param3;
    }

    public void setParam3(String param3) {
        this.param3 = param3;
    }

    @Override
    public String toString() {
        return "Product{" +
                "param1='" + param1 + '\'' +
                ", param2='" + param2 + '\'' +
                ", param3='" + param3 + '\'' +
                '}';
    }
}

抽象建造者

public abstract class Builder {

    public abstract Builder buildParam1(String p1);
    public abstract Builder buildParam2(String p2);
    public abstract Builder buildParam3(String p3);

    public abstract Product build();
}

具体建造者

public class ConcreteBuilder extends Builder {
    private Product product = new Product();
    @Override
    public Builder buildParam1(String p1) {
        product.setParam1(p1);
        return this;
    }

    @Override
    public Builder buildParam2(String p2) {
        product.setParam2(p2);
        return this;
    }

    @Override
    public Builder buildParam3(String p3) {
        product.setParam3(p3);
        return this;
    }

    @Override
    public Product build() {
        return product;
    }
}

导演类

public class Director {
    private Builder builder = null;

    public Director(Builder builder){
        this.builder = builder;
    }

    public void construct(String param1 , String param2, String param3){
        builder.buildParam1(param1)
                .buildParam2(param2)
                .buildParam3(param3);
    }
}

场景类

public class Client {
    public static void main(String[] args){
        Builder builder = new ConcreteBuilder();

        Director director = new Director(builder);
        director.construct("1", "2", "3");
        Product product = builder.build();
    }
}

优点

---

• 封装性，不必知道产品内部细节。
• 容易扩展。
• 控制细节。 具体建造者是独立的，可对建造过程逐步细化，不对其他模块产生影响。

扩展

---

链式调用

产品类

public class Product {
    private String param1;
    private String param2;
    private String param3;

    public static class Builder {
        private Product product = new Product();

        public Builder buildParam1(String p1) {
            product.param1 = p1;
            return this;
        }

        public Builder buildParam2(String p2) {
            product.param2 = p2;
            return this;
        }

        public Builder buildParam3(String p3) {
            product.param3 = p3;
            return this;
        }

        public Product build() {
            return product;
        }
    }

    @Override
    public String toString() {
        return "Product{" +
                "param1='" + param1 + '\'' +
                ", param2='" + param2 + '\'' +
                ", param3='" + param3 + '\'' +
                '}';
    }
}

场景类

public class Client {
    public static void main(String[] args) {
        Product product = new Product.Builder()
                .buildParam1("param1")
                .buildParam2("param2")
                .buildParam3("param3")
                .build();
    }
}

END ~