设计模式之建造者模式

建造者模式(Builder Pattern)：将一个复杂对象（产品）的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。也被称为生成器模式。
建造者模式是复杂对象的组装和创建，是一种对象创建型模式，满足依赖倒转原则（细节依赖于抽象，而非抽象依赖于细节）。

假设一个复杂的对象可以看做是一个产品的话，那么该对象的方法（或称内部表象）就对应了产品的零件，通过建造者模式，客户不需要知道建造的具体细节，只需要指定需要建造的类型就可以得到对应的产品。
建造者模式主要包含四个角色：

• 抽象建造者Builder：声明创建一个产品的各个部件指定的抽象接口。
• 具体建造者ConcreteBuilder：实现抽象接口，创建和组装各个部件。
• 指挥者Director：又称导演类，负责处理复杂对象的组装顺序，隔离了客户与产品的生产过程，客户端只需要与指挥者进行交互。
• 产品类Product：一个具体的产品。

UML关系图如下：

代码如下：

1. Builder.java

/** * 抽象建造者 * @author sywyg * @since 2015.8.27 * */public interface Builder {    void BuildProduct();    void addPartA(String name);    void addPartB(String name);    void addPartC(String name);    Product getResult();}

1. ConcreteBuilder.java

/** * 具体建造者 * @author sywyg * @since 2015.8.27 * */public class ConcreteBuilder implements Builder {    private Product product;    @Override    public void BuildProduct() {        product = new Product();    }    @Override    public void addPartA(String name) {        A a = new A(name);        product.setA(a);        System.out.println("添加部件A成功");    }    @Override    public void addPartB(String name) {        B b = new B(name);        product.setB(b);        System.out.println("添加部件B成功");    }    @Override    public void addPartC(String name) {        C c = new C(name);        product.setC(c);        System.out.println("添加部件C成功");    }    @Override    public Product getResult() {        return product;    }}

1. Director.java

/** * 指挥者，指挥产品的生产过程 * @author sywyg * @since 2015.8.27 * */public class Director {    private Builder builder;    public Director(Builder builder){        this.builder = builder;    }    public Product construct(){        builder.BuildProduct();        builder.addPartA("部件A");        builder.addPartC("部件C");        builder.addPartB("部件B");        return builder.getResult();    }}

1. Product.java

/** * 产品类：由三个部件够成 * @author sywyg * @since 2015.8.27 * */public class Product {    private A a;    private B b;    private C c;    public A getA() {        return a;    }    public void setA(A a) {        this.a = a;    }    public B getB() {        return b;    }    public void setB(B b) {        this.b = b;    }    public C getC() {        return c;    }    public void setC(C c) {        this.c = c;    }}class A{    private String name;    public A(String name){        this.name = name;    }}class B{    private String name;    public B(String name){        this.name = name;    }}class C{    private String name;    public C(String name){        this.name = name;    }}

对上面进行测试，代码如下：

public class Client {    public static void main(String[] args) {        // 首先创建具体建造者        Builder builder = new ConcreteBuilder();        // 根据具体建造者创建导演类        Director director = new Director(builder);        // 直接调用导演类的建造方法创建产品        Product product = director.construct();    }}

建造者优点

• 将一个复杂对象的建造过程封装起来，细节依赖于抽象。
• 允许对象通过多个步骤来创建，并且可以改变工程。
• 向客户隐藏产品内部的表现。
• 产品的实现可以被替换（增加具体建造者），因为客户只看到一个抽象的接口。

缺点

• 与工厂模式相比，采用建造者模式创建对象的客户，需要具备更多的领域知识。
• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，其使用范围受到一定的限制。
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

用途

• 经常被用来创建组合结构。
• 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。