概述

建造者模式（Builder Pattern）是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式属于创建型模式，对使用者而言，只需要指定需要建造的类型就可以获得对象，建造过程和细节不需要了解。
建造者模式的概念听上去有点抽象，但是实际上可以这么说，基本上只要做 Web 开发的基本都用过，只是可能自己不知道这就是建造者模式而已。

示例

我们以家庭作业为例，假设老师会根据每个不同基础的同学布置不同难度的题目来实现一个简单的建造者模式（这里我们需要新建一个 builder 目录，相关类创建在 builder 目录下）。

  • 首先建造一个家庭作业类 Homework.java，这个类里面有四个属性，分别代表四种不同难度的家庭作业。
  1. package builder;
  3. public class Homework {
  4.     private String easyQc;//简答题目
  6.     private String normalQc;//正常题目
  8.     private String MediumQc;//中等难度题目
  10.     private String HardQc;//困难题目
  12.     public String getEasyQc() {
  13.         return easyQc;
  14.     }
  16.     public void setEasyQc(String easyQc) {
  17.         this.easyQc = easyQc;
  18.     }
  20.     public String getNormalQc() {
  21.         return normalQc;
  22.     }
  24.     public void setNormalQc(String normalQc) {
  25.         this.normalQc = normalQc;
  26.     }
  28.     public String getMediumQc() {
  29.         return MediumQc;
  30.     }
  32.     public void setMediumQc(String mediumQc) {
  33.         MediumQc = mediumQc;
  34.     }
  36.     public String getHardQc() {
  37.         return HardQc;
  38.     }
  40.     public void setHardQc(String hardQc) {
  41.         HardQc = hardQc;
  42.     }
  43. }
  • 然后新建一个建造者类 SimpleBuilder.java，建造者类就是用来创建对象的。 ```java package builder;

public class SimpleBuilder { private Homework homework;

  1. public SimpleBuilder(Homework homework) {
  2.     this.homework = homework;
  3. }
  5. public void buildEasyQc(String easyQc){
  6.     homework.setEasyQc(easyQc);
  7. }
  9. public void buildNormalQc(String normalQc){
  10.     homework.setNormalQc(normalQc);
  11. }
  13. public void buildMediumQc(String mediumQc){
  14.     homework.setMediumQc(mediumQc);
  15. }
  17. public void buildHardQc(String hardQc){
  18.     homework.setHardQc(hardQc);
  19. }
  21. public Homework build(){
  22.     return homework;
  23. }

}

  2. 这个建造者类里面持有了家庭作业对象，并且为其每个属性都提供了一个方法进行赋值。
  4. - 最后我们新建一个测试类 TestSimpleBuilder.java 来测试一下。
  6. ```java
  7. package builder;
  9. public class TestSimpleBuilder {
  10.     public static void main(String[] args) {
  11.         SimpleBuilder simpleBuilder = new SimpleBuilder(new Homework());
  12.         simpleBuilder.buildEasyQc("简单题目");//1
  13.         simpleBuilder.buildNormalQc("标准难度题目");//2
  14.         simpleBuilder.buildMediumQc("中等难度题目");//3
  15.         simpleBuilder.buildHardQc("高难度题目");//4
  16.         Homework homework = simpleBuilder.build();
  18.         StringBuilder sb = new StringBuilder();
  19.         sb.append(null == homework.getEasyQc() ? "" : homework.getEasyQc() + ",");
  20.         sb.append(null == homework.getNormalQc() ? "" : homework.getNormalQc() + ",");
  21.         sb.append(null == homework.getMediumQc() ? "" : homework.getMediumQc() + ",");
  22.         sb.append(null == homework.getHardQc() ? "" : homework.getHardQc());
  24.         System.out.println("我的家庭作业有：" + sb.toString());
  25.     }
  26. }

执行 javac builder/*.java 命令进行编译，然后再执行 java builder.TestSimpleBuilder 命令运行测试类（大家一定要自己动手运行哦，只有自己实际去运行了才会更能体会其中的思想）。
建造者/Builder - 图1
这就是一个简单的建造者模式，测试代码中的 1 2 3 4 四行代码可以随意搭配或者取消，这就是建造者模式的灵活性，但是我们可以发现，这里面是直接面向了具体的建造者来编程，在以后的扩展会比较困难，而我们一般都是选择面向抽象编程，所以接下来需要再看一下面向抽象的标准建造者模式写法。

  • 建立一个抽象的建造者类 HomeworkBuilder.java。
  1. package builder;
  3. public abstract class HomeworkBuilder {
  4.     public abstract HomeworkBuilder buildEasyQc(String easyQc);
  6.     public abstract HomeworkBuilder buildNormalQc(String normalQc);
  8.     public abstract HomeworkBuilder buildMediumQc(String mediumQc);
  10.     public abstract HomeworkBuilder buildHardQc(String hardQc);
  12.     public abstract Homework build();
  13. }

这个类和之前一样都是分别为四个属性提供了一个方法，区别是这些方法都返回了建造者本身，这是为了实现后面的链式写法。

  • 新建一个具体的建造者类 ConcreateBuilder.java 继承抽象建造者类 HomeworkBuilder。
  1. package builder;
  3. public class ConcreateBuilder extends HomeworkBuilder {
  4.     private Homework homework;
  6.     public ConcreateBuilder(Homework homework) {
  7.         this.homework = homework;
  8.     }
  10.    @Override
  11.     public HomeworkBuilder buildEasyQc(String easyQc) {
  12.         homework.setEasyQc(easyQc);
  13.         return this;
  14.     }
  16.     @Override
  17.     public HomeworkBuilder buildNormalQc(String normalQc) {
  18.         homework.setNormalQc(normalQc);
  19.         return this;
  20.     }
  22.     @Override
  23.     public HomeworkBuilder buildMediumQc(String mediumQc) {
  24.         homework.setMediumQc(mediumQc);
  25.         return this;
  26.     }
  28.     @Override
  29.     public HomeworkBuilder buildHardQc(String hardQc) {
  30.         homework.setHardQc(hardQc);
  31.         return this;
  32.     }
  34.     @Override
  35.     public Homework build() {
  36.         return homework;
  37.     }
  38. }

最后新建一个测试类 TestBuilder.java 来测试一下。

  1. package builder;
  3. public class TestBuilder {
  4.     public static void main(String[] args) {
  5.         Homework homework = new Homework();
  6.         HomeworkBuilder homeworkBuilder = new ConcreateBuilder(homework);
  7.         homeworkBuilder.buildEasyQc("我是一道简单题目")
  8.                 .buildNormalQc("我是一道标准难度题目")
  9.                 .buildMediumQc("我是一道中等难度题目")
  10.                 .buildHardQc("我是一道高难度题目");
  11.         homework = homeworkBuilder.build();
  13.         StringBuilder sb = new StringBuilder();
  14.         sb.append(null == homework.getEasyQc() ? "" : homework.getEasyQc() + ",");
  15.         sb.append(null == homework.getNormalQc() ? "" : homework.getNormalQc() + ",");
  16.         sb.append(null == homework.getMediumQc() ? "" : homework.getMediumQc() + ",");
  17.         sb.append(null == homework.getHardQc() ? "" : homework.getHardQc());
  19.         System.out.println("我的家庭作业有：" + sb.toString());
  20.     }
  21. }

再次执行 javac builder/*.java 命令进行编译，然后再执行 java builder.TestBuilder 命令运行测试类（大家一定要自己动手运行哦，只有自己实际去运行了才会更能体会其中的思想）。

适用场景

建造者模式适用于一个具有较多属性的复杂产品创建过程，而且产品的各个属性还需要支持动态变化，但属性的种类却总体稳定的场景。所以建造者和工厂模式的区别也很明显，工厂模式是返回一个完整的产品，不支持自由组合属性，而建造者更加灵活，完全可以由使用者自由搭配从而使同一个建造者可以建造出不同的产品。

建造者模式优点

  1. 封装性好，创建和使用分离。

  2. 扩展性好，各个建造类之间相互独立，实现了解耦。

    建造者模式缺点

  3. 创建产品过程中会产生多余的 Builder 对象。

  4. 产品内部发生变化时，建造者都需要修改，成本较大，所以建造者模式的前提需要产品总体稳定，细节自由搭配的场景。