1. 「引例」

××公司把奔驰、宝马的车辆模型都交给我们公司制作，不过这次又额外增加了一个新需求：汽车的启动、停止、喇叭声音、引擎声音都由客户自己控制，他想什么顺序就什么顺序。
分析一下需求，奔驰、宝马都是一个产品，它们有共有的属性，××公司关心的是单个模型的运行过程：奔驰模型A是先有引擎声音，然后再响喇叭；奔驰模型B是先启动起来，然后再有引擎声音，这才是××公司要关心的。
老板满足人家要求，要什么顺序就产生什么顺序的模型出来。我就负责把老板的要求实现出来，而且还要是批量的。
也就是说××公司下单订购宝马A车模，老板马上就找我生产，然后我们就准备开始批量生产这些模型。由我生产出N多个奔驰和宝马车辆模型，这些车辆模型都有run()方法，但是具体到每一个模型的run()方法中间的执行任务的顺序是不同的，最终客户买走后只能是既定的模型。
需求还是比较复杂，先一个一个地解决，先从找一个最简单的切入点——产品类，每个车都是一个产品。

汽车模型抽象

public abstract class CarModel {
  //这个参数是各个基本方法执行的顺序
  private ArrayList<String> sequence = new ArrayList<String>();
  // 模型开始跑动
  protected abstract void start();
  // 模型停下
  protected abstract void stop();
  // 模型鸣笛
  protected abstract void alarm();
  // 引擎响起
  protected abstract void engineBoom();
  // 汽车模型应该会跑，别管是人推的，还是电力驱动，总之要会跑
  final public void run() {
      for (int i = 0; i < this.sequence.size(); i++) {
          String actionName = this.sequence.get(i);
          if (actionName.equalsIgnoreCase("start")) {
              this.start(); // 启动汽车
          } else if (actionName.equalsIgnoreCase("stop")) {
              this.stop(); //停止汽车
          } else if (actionName.equalsIgnoreCase("alarm")) {
              this.alarm(); //喇叭开始叫了
          } else if (actionName.equalsIgnoreCase("engine boom")) {
              this.engineBoom(); //引擎开始轰鸣
          }
      }
  }
  //把传递过来的值传递到类内
  final public void setSequence(ArrayList<String> sequence) {
      this.sequence = sequence;
  }
}

奔驰汽车实现类，宝马同理

public class BenzModel extends CarModel {
  protected void alarm() {
      System.out.println("奔驰车的喇叭声音是这个样子的...");
  }
  protected void engineBoom() {
      System.out.println("奔驰车的引擎是这个声音的...");
  }
  protected void start() {
      System.out.println("奔驰车跑起来是这个样子的...");
  }
  protected void stop() {
      System.out.println("奔驰车应该这样停车...");
  }
}

Test

class Client {
  @Test
  public void test() {
      BenzModel benz = new BenzModel();
      ArrayList<String> sequence = new ArrayList<String>(); //存放run的顺序
      // 客户要求，run的时候先发动引擎
      sequence.add("engine boom");
      sequence.add("start");
      sequence.add("stop");
      //我们把这个顺序赋予奔驰车
      benz.setSequence(sequence);
      benz.run();
  }
}

奔驰车的引擎是这个声音的… 奔驰车跑起来是这个样子的… 奔驰车应该这样停车…

这样设计可以实现汽车动作的执行顺序随意调整，但是这个随着动作数量的增加，实现类也会越来越多，实际不可能一个个来写满所有场景类。
所以就用到了「建造者」来创建顺序：

public abstract class CarBuilder {
    //建造一个模型，你要给我一个顺序要求，就是组装顺序
    public abstract void setSequence(ArrayList<String> sequence);
    // 设置完毕顺序后，就可以直接拿到这个车辆模型
    public abstract CarModel getCarModel();
}
public class BenzBuilder extends CarBuilder {
    private BenzModel benz = new BenzModel();
    public CarModel getCarModel() {
        return this.benz;
    }
    public void setSequence(ArrayList<String> sequence) {
        this.benz.setSequence(sequence);
    }
}
// Test
@Test
public void testBuilder() {
    //存放run的顺序
    ArrayList<String> sequence = new ArrayList<String>();
    sequence.add("engine boom");
    sequence.add("start");
    sequence.add("stop");
    //要一个奔驰车：
    BenzBuilder benzBuilder = new BenzBuilder();
    // 把顺序给这个builder类，制造出这样一个车出来
    benzBuilder.setSequence(sequence);
    // 制造出一个奔驰车
    BenzModel benz = (BenzModel) benzBuilder.getCarModel();
    // 奔驰车跑一下看看
    benz.run();
}

做项目时，有一个共识：需求是无底洞，是无理性的，不可能你告诉它不增加需求就不增加，这4个过程（start、stop、alarm、engine boom）按照排列组合有很多种，××公司可以随意组合，它要什么顺序的车模我就必须生成什么顺序的车模！那我们不可能预知他们要什么顺序的模型，怎么办？封装一下，找一个导演，指挥各个事件的先后顺序，然后为每种顺序指定一个代码，你说一种我们立刻就给你生产处理。
修改一下类图：

我们增加了一个Director类，负责按照指定的顺序生产模型
getABenzModel() 组建出A型号的奔驰车辆模型，其过程为只有启动（start）、停止（stop）方法，其他的引擎声音、喇叭都没有。
getBBenzModel() 组建出B型号的奔驰车，其过程为先发动引擎（engine boom），然后启动，再然后停车，没有喇叭。
getCBMWModel() 组建出C型号的宝马车，其过程为先喇叭叫一下（alarm），然后启动，再然后是停车，引擎不轰鸣。
getDBMWModel() 组建出D型号的宝马车，其过程就一个启动，然后一路跑到黑，永动机，没有停止方法，没有喇叭，没有引擎轰鸣。

其他的E型号、F型号……可以有很多，启动、停止、喇叭、引擎轰鸣这4个方法在这个类中可以随意地自由组合。

public class Director {
  private ArrayList<String> sequence = new ArrayList();
  private BenzBuilder benzBuilder = new BenzBuilder();
  private BMWBuilder bmwBuilder = new BMWBuilder();
  /**
   * A类型的奔驰车模型，先start，然后stop，其他什么引擎、喇叭一概没有
   */
  public BenzModel getABenzModel() {
      //清理场景，这里是一些初级程序员不注意的地方
      this.sequence.clear();
      this.sequence.add("start");
      this.sequence.add("stop");
      this.benzBuilder.setSequence(this.sequence);
      return (BenzModel) this.benzBuilder.getCarModel();
  }
  /**
   * B型号的奔驰车模型，是先发动引擎，然后启动，然后停止，没有喇叭
   */
  public BenzModel getBBenzModel() {
      this.sequence.clear();
      this.sequence.add("engine boom");
      this.sequence.add("start");
      this.sequence.add("stop");
      this.benzBuilder.setSequence(this.sequence);
      return (BenzModel) this.benzBuilder.getCarModel();
  }
  /**
   * C型号的宝马车是先按下喇叭（炫耀嘛），然后启动，然后停止
   */
  public BMWModel getCBMWModel() {
      this.sequence.clear();
      this.sequence.add("alarm");
      this.sequence.add("start");
      this.sequence.add("stop");
      this.bmwBuilder.setSequence(this.sequence);
      return (BMWModel) this.bmwBuilder.getCarModel();
  }
  /**
   * D类型的宝马车只有一个功能，就是跑，启动起来就跑，永远不停止
   */
  public BMWModel getDBMWModel() {
      this.sequence.clear();
      this.sequence.add("start");
      this.bmwBuilder.setSequence(this.sequence);
      return (BMWModel) this.benzBuilder.getCarModel();
  }
}

📌注：上面每个方法都有一个this.sequence.clear()，ArrayList和HashMap如果定义成类的成员变量，那你在方法中的调用一定要做一个clear的动作，以防止数据混乱。

@Test
public void testDirector() {
  Director director = new Director();
  for (int i = 0; i < 10000; i++) { //1万辆A类型的奔驰车
      director.getABenzModel().run();
  }
  for (int i = 0; i < 1000000; i++) { //100万辆B类型的奔驰车
      director.getBBenzModel().run();
  }
  for (int i = 0; i < 10000000; i++) { //1000万辆C类型的宝马车
      director.getCBMWModel().run();
  }
}

2. 「定义」

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

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

通用类图

Product「产品类」
- 实现了模板方法模式，也就是有模板方法和基本方法，这个参考「模板方法模式」。例子中的BenzModel和BMWModel就属于产品类。
Builder「抽象建造者」
- 规范产品的组建，一般是由子类实现。例子中的CarBuilder就属于抽象建造者。
ConcreteBuilder「具体建造者」
- 实现抽象类定义的所有方法，并且返回一个组建好的对象。例子中的BenzBuilder和 BMWBuilder就属于具体建造者。
Director「导演类」
- 负责安排已有模块的顺序，然后告诉Builder开始建造。

public class Product {
    public void doSomething(){
        // 独立业务处理
    }
}
public abstract class Builder {
    //设置产品的不同部分，以获得不同的产品
    public abstract void setPart();
    // 建造产品
    public abstract Product buildProduct();
}
public class ConcreteProduct extends Builder {
    private Product product = new Product();
    //设置产品零件
    public void setPart() {
        /** 产品类内的逻辑处理 */
    }
    //组建一个产品
    public Product buildProduct() {
        return product;
    }
}
public class Director {
    private Builder builder = new ConcreteProduct();
    //构建不同的产品
    public Product getAProduct() {
        builder.setPart();
        /** 设置不同的零件，产生不同的产品 */
        return builder.buildProduct();
    }
}

📌注：

如果有多个产品类就有几个具体的建造者，而且这多个产品类具有相同接口或抽象类。
导演类起到封装的作用，避免高层模块深入到建造者内部的实现类。当然，在建造者模式比较庞大时，导演类可以有多个。

3. 「应用」

1.「优点」

封装性
- 使用建造者模式可以使客户端不必知道产品内部组成的细节。
建造者独立，容易扩展
- BenzBuilder和BMWBuilder是相互独立的，对系统的扩展非常有利。
便于控制细节风险
- 由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

2.「使用场景」

相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。
多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。
- 可以想引例里面的汽车产品是由很多零件组装成的。
产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适。
在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过创建者模式柔化创建过程，本身已经违反设计的最初目标。

3.「注意事项」

📌建造者模式关注的是零件类型和装配工艺（顺序），这是它与工厂方法模式最大不同的地方，虽然同为创建类模式，但是注重点不同。

建造者模式最主要的功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了，通俗地说就是零件的装配，顺序不同产生的对象也不同；而工厂方法则重点是创建，创建零件是它的主要职责，组装顺序则不是它关心的。

4. 「最佳实践」

在使用建造者模式的时候考虑一下模板方法模式，别孤立地思考一个模式，僵化地套用一个模式会让你受害无穷！

Java 设计模式

3 『建造者模式』

1. 「引例」

2. 「定义」

3. 「应用」

1.「优点」

2.「使用场景」

3.「注意事项」

4. 「最佳实践」

3 『建造者模式』

1. 「引例」

2. 「定义」

3. 「应用 」

1.「优点」

2.「使用场景」

3.「注意事项」

4. 「最佳实践」

3. 「应用」