Builder 建造者模式

前言

当一个对象的构造十分复杂时，我们需要将“构造过程”和他的“表示”进行分离，使得同样的构建过程可以表示不同的对象。

这个时候，需要使用 Builder 模式。用户只需指定建造者的类型就可以得到对应的产品。而具体如何构造用户并不关心。

而不同的对象的构造又是不同的，因此需要不同的建造者一一对应。

类图设计如下：

实例代码

Builer 相关：Builder, BuilderA, BuilderB

/** 抽象创建者 */
public abstract class Builder {
 
  abstract Product getProduct();
 
  abstract void builderName();
 
  abstract void builderBody();
}
 
/** 具体创建者，实际场景中，会有多个实现，即一个产品实现对应一个构建者 */
public class BuilderA extends Builder {
 
  Product product = new ProductA();
 
  @Override
  Product getProduct() {
    return product;
  }
 
  /** 具体构建者需要知道如何构建对象 */
  @Override
  void builderName() {
    product.name = "Name A";
  }
 
  @Override
  void builderBody() {
    product.body = "Body A";
  }
}
 
/** 具体创建者，实际场景中，会有多个实现，即一个产品实现对应一个构建者 */
public class BuilderB extends Builder {
 
  Product product = new ProductB();
 
  @Override
  Product getProduct() {
    return product;
  }
 
  /** 具体构建者需要知道如何构建对象 */
  @Override
  void builderName() {
    product.name = "Name B";
  }
 
  @Override
  void builderBody() {
    product.body = "Body B";
  }
}

Product 相关：Product，ProductA，ProductB

/** 产品，可以被抽象 */
public abstract class Product {
 
  String name;
  String body;
}
public class ProductA extends Product{
  String nameA = "New A";
 
  @Override
  public String toString() {
    return "ProductB{" +
        "nameA='" + nameA + '\'' +
        ", name='" + name + '\'' +
        ", body='" + body + '\'' +
        '}';
  }
}
public class ProductB extends Product{
 
  String nameB = "New B";
 
  @Override
  public String toString() {
    return "ProductB{" +
        "nameB='" + nameB + '\'' +
        ", name='" + name + '\'' +
        ", body='" + body + '\'' +
        '}';
  }
}

Director 相关：Director

/** 指挥者 */
public class Director {
 
  /** 此方法可以固定构建对象的过程，只需要传递具体构建者即可 */
  void createProduct(Builder builder) {
    builder.builderName();
    builder.builderBody();
  }
}

测试类：

/** 测试客户端 */
public class BuilderClient {
 
  public static void main(String[] args) {
    Builder a = new BuilderA();
    Builder b = new BuilderB();
 
    Director director = new Director();
    director.createProduct(a);
    director.createProduct(b);
 
    System.out.println(a.getProduct());
    System.out.println(b.getProduct());
  }
}

结果：

ProductB{nameA='New A', name='Name A', body='Body A'}
ProductB{nameB='New B', name='Name B', body='Body B'}

从上面的代码中可以看出，通过构造不同的 Builder，可以得到对应的产品。大家可能会问，为什么不直接创建产品？实际上，生产环境中的构造过程远比 demo 复杂，将构造对象的复杂过程全部放入指挥者 Director 中，能够有效避免创建过程的错误。

通过使用 Builder，能够重复利用创建者，确保每次构造产品都是正确的。

即：

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

这里的“同样的构建过程” 就是 Director 中的 createProduct 方法。

“不同的表示”，则是每个 Builder 实现对应一个具体产品的具体构建内容。具体内容可以根据业务需求进行创建。

Spring 框架中，Builder 模式无处不在。总之，Builder 就是为了构建不同的对象的同时，提供了稳定的构建过程，所有对象的构建过程都是被 Driector 指挥的。而对象的具体构建内容则是子类 Builder 来根据需求实现。有效的将对象的内容和构建过程分离，同时也保证了构建过程的稳定，不易出错。