设计模式：创建型模式--建造者模式（Builder Pattern）

设计模式：创建型模式–建造者模式（Builder Pattern）

1. 概述

将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。

• 分离部件的构造（由Builder负责）和装配（由Director负责），从而可以构造出复杂的对象。
• 实现了构建算法与装配算法的解耦，实现了更好的复用。不同的构建器，相同的装配，也可以获得不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。
• 建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

2. 组成结构

建造者（Builder）模式包含如下角色：

• 产品类（Product）： 要创建的复杂对象。
• 抽象建造者类（Builder）： 这个接口规定要实现的复杂对象的部件的创建，并不涉及具体的部件对象的创建。
• 具体建造者类（Concrete Builder）： 实现Builder接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。
• 指挥者类（Director）： 调用具体建造者来创建复杂对象的各个部分，指导者不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

类图如下：

3. 具体实例

创建共享单车

生产自行车是一个复杂的过程，它包含了车架，车座等组件的生产。而车架又有碳纤维，铝合金等材质的，车座有橡胶，真皮等材质。对于自行车的生产就可以使用建造者模式。

这里Bike是产品，包含车架，车座等组件；Builder是抽象建造者，MobikeBuilder和OfoBuilder是具体的建造者；Director是指挥者。类图如下：

具体的代码如下：

• 产品类Bike：

  要创建的复杂对象。

  /**
   * @author zzay
   * @className Bike
   * @description 创建型模式-建造者模式：产品类
   * @create 2022/02/26 23:33
   */
  public class Bike {
  
      private String frame;
  
      private String seat;
  
      public String getFrame() {
          return frame;
      }
  
      public void setFrame(String frame) {
          this.frame = frame;
      }
  
      public String getSeat() {
          return seat;
      }
  
      public void setSeat(String seat) {
          this.seat = seat;
      }
      
  }
  

• 抽象建造者类Builder：

  这个接口规定要实现的复杂对象的部件的创建，并不涉及具体的部件对象的创建。

  /**
   * @author zzay
   * @className Builder
   * @description 创建型模式-建造者模式：抽象建造者类
   * @create 2022/02/26 23:34
   */
  public abstract class Builder {
  
      protected Bike myBike = new Bike();
  
      public abstract void buildFrame();
  
      public abstract void buildSeat();
  
      public abstract Bike createBike();
  
  }
  

• 具体建造者类 MobikeBuilder和OfoBuilder：

  实现Builder接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。

  /**
   * @author zzay
   * @className MobikeBuilder
   * @description 创建型模式-建造者模式：具体建造者类
   * @create 2022/02/26 23:34
   */
  public class MobikeBuilder extends Builder {
  
      @Override
      public void buildFrame() {
          myBike.setFrame("铝合金");
          System.out.println("制造了Mobike的铝合金车架");
      }
  
      @Override
      public void buildSeat() {
          myBike.setSeat("真皮");
          System.out.println("制造了Mobike的真皮车座");
      }
  
      @Override
      public Bike createBike() {
          return myBike;
      }
  
  }
  
  /**
   * @author zzay
   * @className OfoBuilder
   * @description 创建型模式-建造者模式：具体建造者类
   * @create 2022/02/26 23:34
   */
  public class OfoBuilder extends Builder {
  
      @Override
      public void buildFrame() {
          myBike.setFrame("碳纤维");
          System.out.println("制造了OfoBike的碳纤维车架");
      }
  
      @Override
      public void buildSeat() {
          myBike.setSeat("橡胶");
          System.out.println("制造了OfoBike的橡胶车座");
      }
  
      @Override
      public Bike createBike() {
          return myBike;
      }
  
  }
  

• 指挥者类Director：

  调用具体建造者来创建复杂对象的各个部分，指导者不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

  /**
   * @author zzay
   * @className Director
   * @description 创建型模式-建造者模式：指挥者类
   * @create 2022/02/26 23:34
   */
  public class Director {
  
      private Builder myBuilder;
  
      public Director(Builder builder) {
          myBuilder = builder;
      }
  
      // 调用具体建造者来创建复杂对象的各个部分。
      // 指导者不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
      public Bike construct() {
          myBuilder.buildFrame();
          myBuilder.buildSeat();
          return myBuilder.createBike();
      }
  
  }
  

• 测试类Client：

  /**
   * @author zzay
   * @className Client
   * @description 创建型模式-建造者模式：测试类
   * @create 2022/02/26 23:34
   */
  public class Client {
  
      public static void main(String[] args) {
          showBike(new MobikeBuilder());
          showBike(new OfoBuilder());
      }
  
      /**
       * 展示建造的Bike的具体信息。
       */
      private static void showBike(Builder builder) {
          // 根据需求，传入想要建造的产品的对应Builder。
          Director director = new Director(builder);
          // 之后，指挥者会指挥该Builder进行相应的产品建造。
          Bike bike = director.construct();
          System.out.println(bike.getFrame() + "-" + bike.getSeat());
      }
  
  }
  

注意：

上面示例是 Builder模式的常规用法，指挥者类 Director 在建造者模式中具有很重要的作用，它用于指导具体构建者如何构建产品，控制调用先后次序，并向调用者返回完整的产品类。

但是有些情况下需要简化系统结构，可以把指挥者类和抽象建造者进行结合。代码如下：

// 指挥者类Director和抽象建造者类Builder结合而成的Builder类
public abstract class Builder {

    protected Bike mBike = new Bike();

    public abstract void buildFrame();
    
    public abstract void buildSeat();
    
    public abstract Bike createBike();
    
    public Bike construct() {
        this.buildFrame();
        this.BuildSeat();
        return this.createBike();
    }
    
}

说明：

这样做确实简化了系统结构，但同时也加重了抽象建造者类的职责，也不是太符合单一职责原则，如果construct()过于复杂，建议还是封装到Director中。

4. 优缺点

• 优点：

  • 建造者模式的封装性很好，使用建造者模式可以有效的封装变化。**在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的。**因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。
  • 在建造者模式中，客户端不必知道产品内部组成的细节。能够将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
  • **可以更加精细地控制产品的创建过程。**将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
  • 建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码。因此，不会对原有功能引入风险，符合开闭原则。

• 缺点：

  • 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式。因此，其使用范围受到一定的限制。

5. 使用场景

建造者模式（Builder Pattern）创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定。因此，通常在以下场合使用：

• 一些基本部件不会变，而其组合经常变化的时候。
• 需要生成的对象具有复杂的内部结构。
• 需要生成的对象内部属性本身相互依赖。
• 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。

6. 模式扩展

建造者模式除了上面的用途外，在开发中还有一个常用的使用方式：就是当一个类构造器需要传入很多参数时，如果创建这个类的实例，代码可读性会非常差，而且很容易引入错误。此时，就可以利用建造者模式进行重构。

• 重构前–实体类PhoneBefore代码：

  在客户端代码中构建Phone对象，传递了四个参数。如果参数更多呢？代码的可读性及使用的成本比较高。

  /**
   * @author zzay
   * @className PhoneBefore
   * @description 创建型模式-建造者模式：优化前的多参数构造器
   * @create 2022/02/27 00:10
   */
  public class PhoneBefore {
  
      private String cpu;
  
      private String screen;
  
      private String memory;
  
      private String mainboard;
  
      public PhoneBefore(String cpu, String screen, String memory, String mainboard) {
          this.cpu = cpu;
          this.screen = screen;
          this.memory = memory;
          this.mainboard = mainboard;
      }
  
      public String getCpu() {
          return cpu;
      }
  
      public void setCpu(String cpu) {
          this.cpu = cpu;
      }
  
      public String getScreen() {
          return screen;
      }
  
      public void setScreen(String screen) {
          this.screen = screen;
      }
  
      public String getMemory() {
          return memory;
      }
  
      public void setMemory(String memory) {
          this.memory = memory;
      }
  
      public String getMainboard() {
          return mainboard;
      }
  
      public void setMainboard(String mainboard) {
          this.mainboard = mainboard;
      }
  
      @Override
      public String toString() {
          return "PhoneBefore{" +
                  "cpu='" + cpu + '\'' +
                  ", screen='" + screen + '\'' +
                  ", memory='" + memory + '\'' +
                  ", mainboard='" + mainboard + '\'' +
                  '}';
      }
      
  }
  

• 重构前–测试类ClientBefore代码：

  /**
   * @author zzay
   * @className ClientBefore
   * @description 测试类-Before
   * @create 2022/02/27 00:16
   */
  public class ClientBefore {
  
      public static void main(String[] args) {
          PhoneBefore phoneBefore = new PhoneBefore("intel","Samsung","Kingston","华硕");
          System.out.println(phoneBefore);
      }
  
  }
  

• 重构后–实体类PhoneAfter代码如下：

  重构后的代码在使用起来更方便，某种程度上也可以提高开发效率。从软件设计上，对程序员的要求比较高。

  /**
   * @author zzay
   * @className PhoneAfter
   * @description 创建型模式-建造者模式：优化后的多参数构造器
   * @create 2022/02/27 00:10
   */
  public class PhoneAfter {
  
      private String cpu;
  
      private String screen;
  
      private String memory;
  
      private String mainboard;
  
      public PhoneAfter(Builder builder) {
          cpu = builder.cpu;
          screen = builder.screen;
          memory = builder.memory;
          mainboard = builder.mainboard;
      }
  
      @Override
      public String toString() {
          return "Phone{" +
                  "cpu='" + cpu + '\'' +
                  ", screen='" + screen + '\'' +
                  ", memory='" + memory + '\'' +
                  ", mainboard='" + mainboard + '\'' +
                  '}';
      }
  
      /**
       * 建造者模式除了上面的用途外，在开发中还有一个常用的使用方式：
       * 就是当一个类构造器需要传入很多参数时，如果创建这个类的实例，
       * 代码可读性会非常差，而且很容易引入错误。此时，就可以利用建造者模式进行重构。
       */
      public static final class Builder {
  
          private String cpu;
  
          private String screen;
  
          private String memory;
  
          private String mainboard;
  
          public Builder() {}
  
          public Builder cpu(String val) {
              cpu = val;
              return this;
          }
  
          public Builder screen(String val) {
              screen = val;
              return this;
          }
  
          public Builder memory(String val) {
              memory = val;
              return this;
          }
  
          public Builder mainboard(String val) {
              mainboard = val;
              return this;
          }
  
          public PhoneAfter build() {
              return new PhoneAfter(this);
          }
  
      }
  
  }
  

• 重构后–测试类ClientAfter代码：

  /**
   * @author zzay
   * @className ClientAfter
   * @description 测试类：After
   * @create 2022/02/27 00:17
   */
  public class ClientAfter {
  
      public static void main(String[] args) {
          PhoneAfter phoneAfter = new PhoneAfter.Builder()
                  .cpu("intel")
                  .mainboard("华硕")
                  .memory("Kingston")
                  .screen("Samsung")
                  .build();
          System.out.println(phoneAfter);
      }
  
  }
  

7. 对比其他创建型模式

7.1 工厂模式 vs 建造者模式

• 工厂方法模式：注重整体对象的创建方式。
• 建造者模式：注重部件构建的过程，意在一步一步地精确构造创建出一个复杂的对象。

举个例子说明两者的差异：如要制造一个超人，若使用工厂方法模式，直接产生出来的就是一个力大无穷、能够飞翔的超人；而如果使用建造者模式，则需要组装手、头、脚、躯干等部分，再组装成为超人。

7.2 抽象工厂模式 vs 建造者模式

• 抽象工厂模式：实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合。采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。
• 建造者模式：要求按照指定的蓝图建造产品，其主要目的是通过组装零配件而产生一个新产品。

举个例子，如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品；那建造者模式就是一个汽车组装工厂，通过对部件的组装返回一辆完整的汽车。