【23种设计模式】6建造者模式

描述：对象的构建与表示分离，同样的构建过程创建不同的表示
优点：解耦对象和它的构建过程，建造者独立，容易扩展
缺点：需要对象有较多的共同点，对象内部变化导致建造者变多

应用：指定属性构建对象，组装小对象，组成大对象

---

classDiagram
  class Product{
    +doSomething() void
  }
  class Builder{
    <>
    +buildPartA()* void
    +buildPartB()* void
    +buildProduct()* Product
  }
  class ConcreteBuilder{
    -product Product
    constructor(product : Product)
    +buildPartA() void
    +buildPartB() void
    +buildProduct() Product
  }
  class Director{
    -_builder : Builder
    constructor(builder : Builder)
    setbuilder(builder : Builder)
    +constructorProduct()
  }
  Director o-- Builder :聚合
  Builder <|.. ConcreteBuilder :实现
  Product <.. ConcreteBuilder :依赖

• 对建造者抽象，指定需要抽象出哪些产品
  • 实现建造者
• 指挥者，处理建造的流程
• 实例化一个建造者，交给指挥者，指挥者的实例进行构建

// 产品角色
class Product {
    public doSomething() : void {
        // 独立业务
    }
}
// 抽象建造者
abstract class Builder {
    public abstract buildPartA() : void;
    public abstract buildPartB() : void;
    public abstract buildPartC() : void;
    public abstract buildProduct() : Product;
}
// 具体建造者
class ConcreteBuilder extends Builder {
    private product : Product;
    constructor(product : Product) {
        super();
        this.product = product;
    }
    public buildPartA() : void {}
    public buildPartB() : void {}
    public buildPartC() : void {}
    // 最终组建一个产品
    public buildProduct() : Product {
        return this.product;
    }
}
// 指挥者
class Director {
    private _builder : Builder;
    constructor(builder : Builder) {
        this._builder = builder;
    }
    set builder(builder : Builder) {
        this._builder = builder;
    }
    // 将处理建造的流程交给指挥者
    public constructorProduct() {
        this._builder.buildPartA();
        this._builder.buildPartB();
        this._builder.buildPartC();
        return this._builder.buildProduct();
    }
}
// 使用
const builder : Builder = new ConcreteBuilder(new Product());
const director : Director = new Director(builder);
const product : Product = director.constructorProduct();