Java设计模式之建造者模式

建造者模式

介绍

提起Builder，我们第一时间想到的就是建筑物，高楼大厦。在建造高楼大厦的时候，需要先打地基，搭建建筑框架，然后自下而上地一层一层盖起来。通常，在建造这种具有复杂结构的物体时，很难一气呵成。我们需要首先建造组成这个物体的各个部分，然后分阶段将它们组装起来。而建造者模式(Builder Pattern),顾名思义，正是为建造复杂的对象而存在。
建造者模式的定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

实现

在建造者模式中，一共有以下五个角色：

1. Builder(建造者)
   Builder角色负责定义用于生成实例的接口。
2. ConcreteBuilder(当前建造者)
   ConcreteBuilder角色是负责实现Builder角色的接口的类。这里定义了在生成实例时实际上被调用的方法。
3. Director(导演类)
   Director角色负责使用Builder角色的接口来生成实例。它并不依赖于ConcreteBuilder角色。为了确保不论ConcreteBuilder角色是如何被定义的，Director角色都能正常工作，它只调用在Builder角色中被定义的方法。
4. Product(产品类)
   这是一个具体类而不是抽象类，一般来说会是一个比较复杂的对象，即创建实例的过程比较复杂（步骤多或者步骤顺序有要求等等）。

5. Client(使用者)
   Client是最终使用Builder模式的用户。
   
   下面，我们写一段金拱门制作汉堡套餐的示例程序。

   建造者

   public abstract class Builder {
       public abstract void buildHamburger();
       public abstract void buildDrink();
       public abstract void buildRefreshments();
       public abstract void getProduct();
   }

   当前建造者

   public class ConcreteBuilder extends Builder {
       private Product product = new Product();    
       @Override
       public void buildHamburger() {
           product.setHamburgerName("巨无霸汉堡x1");
       }
       @Override
       public void buildDrink() {
           product.setDrinkName("纯牛奶x1");
       }
       @Override
       public void buildRefreshments() {
           product.setRefreshmentName("麦乐鸡x4");
       }
       @Override
       public void getProduct() {
           System.out.println("巨无霸套餐：" + product.getHamburgerName() + "+" +
                product.getRefreshmentName() + "+" + product.getDrinkName());
       }
   }

   导演类

   public class Director {
       private Builder builder;
       public Director(Builder builder) {
           this.builder = builder;
       }
       public void construct() {
           builder.buildHamburger();
           builder.buildRefreshments();
           builder.buildDrink();
       }
   }

   产品类

   public class Product {
       private String hamburgerName;
       private String refreshmentName;
       private String drinkName;
       public String getHamburgerName() {
           return hamburgerName;
       }
       public void setHamburgerName(String hamburgerName) {
           this.hamburgerName = hamburgerName;
       }
       public String getRefreshmentName() {
           return refreshmentName;
       }
       public void setRefreshmentName(String refreshmentName) {
           this.refreshmentName = refreshmentName;
       }
       public String getDrinkName() {
           return drinkName;
       }
       public void setDrinkName(String drinkName) {
           this.drinkName = drinkName;
       }
   }

   使用者

   public class Client {
       public static void main(String[] args) {
           Builder builder = new ConcreteBuilder();
           Director director = new Director(builder);
           director.construct();
           builder.getProduct();
       }
   }

   输出结果

   巨无霸套餐：巨无霸汉堡x1+麦乐鸡x4+纯牛奶x1

建造者模式总结

1. 优点
   1）封装性好。建造者模式将复杂对象的创建依次拆分，并且封装在了各个Builder类内部，外部调用的人只需要正确的调用建造者和导演类就能创建对象，而不用关心内部是如何构建的。
   2）易扩展。有新需求时，只需要新建一个新的建造者类就可以实现，不用去修改之前的代码，扩展很方便，也不会对既存的业务逻辑产生影响。

2. 缺点
   1）使用建造者模式，需要各个产品的创建过程具有很大的相似度，如果产品构建差异过大，则不适合使用建造者模式。
   2）和工厂模式一样，产品扩展的越多，具体的建造者类也就越多，一定程度上增加了系统的复杂度。

3. 和工厂模式区别
   工厂模式将对象的创建过程全部封装在了工厂类里面，而建造者模式的各个建造者类只负责各个组件的创建，最后对象的组装由导演类来完成。
   因此，相对于工厂模式来说，建造者模式适用于更复杂对象的创建。