莫那·鲁道

惯于闲看花飞花落, 心念天际云卷云舒.

Coder, 欢迎留言 😆.


GitHub

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 来根据需求实现。有效的将对象的内容和构建过程分离,同时也保证了构建过程的稳定,不易出错。