一、概述

• 建造者模式（Builder Pattern）：又叫生成器模式，是一种对象构建模式。它可以将复杂的建造过程抽象出来，使这个抽象过程的不同实现方式可以构造出不同表现的对象。
• 建造者模式是一步一步创建一个复杂的对象，它允许用户只通过制定复杂对象的类型和内容就可以构建它们，用户不需要直到内部的具体构建细节。
• 建造者的四个角色
  • Product（产品角色）：一个具体的产品对象
  • Builder（抽象建造者）：创建一个Product对象各个部件的指定接口/抽象类
  • ConcreteBuilder（具体建造者）：实现接口，构建和装配各个部件
  • Director（指挥者）：构建一个使用Builder接口的对象。主要有两个作用：一是隔离客户与对象的生成过程；二是负责控制产品对象的生产过程

二、案例

• 以盖房为例，AbstractHouse为抽象产品，House为具体产品，Builder为抽象建造者，CommonHouseBuilder和HighBuildingBuilder为具体建造者，HouseDirector为指挥者
• 即，House本身是一块空地，用户告诉Director（包工头），“我想要xxx的房子”。包工头就为指挥相应的工人，按照相应的图纸（也就是Builder），在空地上建造用户的房子，并将房子最后交付用户。

public abstract class AbstractHouse {
  private String basic;
  private String wall;
  private String roofed;

  public String getBasic() {
    return basic;
  }

  public void setBasic(String basic) {
    this.basic = basic;
  }

  public String getWall() {
    return wall;
  }

  public void setWall(String wall) {
    this.wall = wall;
  }

  public String getRoofed() {
    return roofed;
  }

  public void setRoofed(String roofed) {
    this.roofed = roofed;
  }

  @Override
  public String toString() {
    return "AbstractHouse{" +
            "basic='" + basic + '\'' +
            ", wall='" + wall + '\'' +
            ", roofed='" + roofed + '\'' +
            '}';
  }
}

public class House extends AbstractHouse {
}

public interface Builder {
  void buildBasic();

  void buildWalls();

  void roofed();

  AbstractHouse build();
}

public class CommonHouseBuilder implements Builder {
  private AbstractHouse house = new House();

  @Override
  public void buildBasic() {
    house.setBasic("普通的地基");
  }

  @Override
  public void buildWalls() {
    house.setWall("普通的外墙");
  }

  @Override
  public void roofed() {
    house.setRoofed("普通的屋顶");
  }

  @Override
  public AbstractHouse build() {
    return house;
  }
}

public class HouseDirector {
  private Builder builder;

  public HouseDirector() {
  }

  public HouseDirector(Builder builder) {
    this.builder = builder;
  }

  public void setBuilder(Builder builder) {
    this.builder = builder;
  }

  public AbstractHouse constructHouse() {
    builder.buildBasic();
    builder.buildWalls();
    builder.roofed();
    return builder.build();
  }

  public static void main(String[] args) {
    HouseDirector houseDirector = new HouseDirector(new CommonHouseBuilder());
    AbstractHouse house = houseDirector.constructHouse();
    System.out.println(house);
    houseDirector.setBuilder(new HighBuildingBuilder());
    house = houseDirector.constructHouse();
    System.out.println(house);
  }
}

三、总结

• 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品
• 每一个具体建造者都相对独立，而与其他建造者无关。用户使用不同的建造者就可以获得不同的产品对象
• 增加新的具体建造者无需修改原有类库的代码，指挥者针对抽象建造者类编程，系统拓展方便，符合“开闭原则”
• 建造者模式所创建的产品一般具有较多的共同点，其组成成分相似，如果产品之间的差异性很大，则不适合使用建造者模式
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，因此在这种情况下，要考虑是否选择建造者模式
• 抽象工厂模式 VS 建造者模式：工厂模式是什么样的产品由什么样的工厂建造，每个产品都有一个具体的实现类；而建造者模式是，基于同一个产品，根据不同的蓝图，建造出不同的产品。