【设计模式

1、模式简介

　　建造者模式也叫生成器模式，和抽象工厂模式相似，也是一种构建复杂对象的模式。

建造者模式中的角色分类：

• 抽象建造者Builder：接口类型，用于规范各个产品的组成部分；
• 具体建造者ConcreteBuilder：实现Builder中的所有方法，并且返回一个构造好的产品实例；
• 指导者Director：根据用户的需求安排产品各组件的生产顺序，然后告诉具体建造者开始建造；
• 产品Product：用户最终看到的复杂对象。

各组成部分之间的UML框架如下图所示：

2、代码

　　项目框架如下图所示：

 

　　产品的组成部分Part父类中的代码：

public class Part {
      private String name;
 
      protected void setName(String name) {
           this.name = name;
      }
 
      public void onPartPrepared() {
           System.out.println(this.name + "prepared......");
      }
}

　　Part的子类PartA中的代码：

public class PartA extends Part {
      public PartA() {
           super.setName("PartA");
      }
}

　　产品类Product中的代码：

public class Product {
      private List<Part> parts;
 
      public Product() {
           this.parts = new ArrayList<>();
      }
 
      public void addComponent(Part part) {
           parts.add(part);
      }
 
      public void display() {
           for (Part p : parts) {
                 p.onPartPrepared();
           }
           System.out.println();
      }
}

　　建造者的父类Builder中的代码：

public abstract class Builder {
      protected Product product;
 
      public abstract Product buildProduct();
}

　　Builder的子类ProductBuilder1中的代码：

public class ProductBuilder1 extendsBuilder {
 
      @Override
      public Product buildProduct() {
           super.product = new Product();
           super.product.addComponent(new PartA());
           super.product.addComponent(new PartB());
           super.product.addComponent(new PartD());
           return super.product;
      }
}

　　指导者Director中的代码：

public class Director {
      private String name;
      private Builder builder;
 
      public Director(String name, Builder builder) {
           this.name = name;
           this.builder = builder;
      }
 
      public void constructComponent() {
           System.out.println("Preparing Components For " + name);
           Productproduct = builder.buildProduct();
           product.display();
      }
}

　　测试类Test中的代码：

public class Test {
      public static void main(String[] args) {
           Directordirector1 = new Director("Product 01", new ProductBuilder1());
           director1.constructComponent();
 
           Directordirector2 = new Director("Product 02", new ProductBuilder2());
           director2.constructComponent();
 
           Directordirector3 = new Director("Product 03", new ProductBuilder3());
           director3.constructComponent();
      }
}

　　运行结果如下图所示：

3、总结

符合以下要求的对象可以使用建造者模式来创建：

• 需要创建的对象是一个组合结构；
• 需要创建的对象的创建过程不必被用户知道；
• 允许对象通过多个步骤来创建，并且可以改变过程。

建造者模式的优点：

• 封装了对象创建的具体代码；
• 可以更加精细的控制对象的构造过程；
• 将对象的创建过程与创建该对象的类解耦，提高了灵活性；
• 指挥者的代码不需要修改，符合“开闭原则”。

建造者模式的缺点：

　　每种对象的创建以及同一种对象的不同方式的创建都需要一个单独的具体建造者类。

建造者模式与抽象工厂模式的区别：

• 建造者模式构建对象是一步一步完成的，关注的是各零件的工艺顺序；而抽象工厂模式将一个系列的产品看作一个整体，即将这个系列的产品的构造封装成一个方法，最终直接返回产品；
• 抽象工厂模式中用户是直接与工厂交互的，通过将用户需求传达给工厂直接生产产品；而建造者模式中用户是与指导者交互的，由指导者与建造者交流生产产品。

　　从上面的区别可以看出，建造者模式适合生产的产品复杂度比抽象工厂模式适合生产的产品的复杂度要高。

　　最后贴出建造者模式的GitHub地址：【GitHub - Builder】。