[设计模式] —— Builder 生成器模式

Builder 生成器模式

动机

面临着”一个复杂对象“的创建工作，其通常由各个部分的子对象用一定的算法构成，由于需求变化，这个复杂对象的各个部分经常变化，但它们组合在一起的算法很稳定。

定义

将一个复杂对象与其表示分离，使得同样的构建过程（稳定）可以构建不同的表示（变化）。

示例代码

class House {
public:
 // ...
 House* init() {
    this->BuildPart1();
    for(int i = 0; i < 4; ++i) {
        this->BuildPart2();
    }

    if(this->BuildPart3()) {
        this->BuildPart4();
    }
   	return this;
 }

 virtual ~House() {}

protected:
 virtual void BuildPart1() = 0;
 virtual void BuildPart2() = 0;
 virtual bool BuildPart3() = 0;
 virtual void BuildPart4() = 0;
};

class StoneHouse : public House {
protected:
 virtual void BuildPart1() {
    // ...
 }
 // 其他虚函数实现
};

上面的形式就基本符合 Builder 生成器的模式了，这里假设有一个 House 类，里面主要定义了一个房子的构建过程 init() 函数，然后具体房子的搭建步骤则是可以变化的，这里有点像前面的 Template Method 的形式。即对象各部分经常变化（建造使用的材料等），但是形成的算法是稳定的（搭建房子就是固定的这几步）。

我们可以进一步地将 House 基类拆分。

class House {
    // ...
};

class StoneHouse : public House {
 // ...
};

class HouseBuilder {
public:
  House* GetResult() {
      return pHouse;
  }

  virtual ~HouseBuilder() {}

protected:
 House* pHouse; // 这里的 House 对象可以通过成员函数new一个出来，不一定要类参数传入
 virtual void BuildPart1() = 0;
 virtual void BuildPart2() = 0;
 virtual bool BuildPart3() = 0;
 virtual void BuildPart4() = 0;
};

class StoneHouseBuilder : public HouseBuilder {
  // 虚函数实现
};

class HouseDirector {
  HouseBuilder* pHouseBuilder;
public:
  HouseDirector(HouseBuilder* h) : pHouseBuilder(h) {}
  House init() {
    pHouseBuilder->BuildPart1();
    for(int i = 0; i < 4; ++i) {
        pHouseBuilder->BuildPart2();
    }

    if(pHouseBuilder->BuildPart3()) {
        pHouseBuilder->BuildPart4();
    }
    pHouseBuilder->GetResult();
 }
};

上面将稳定的部分拆成了 HouseDirector 类，然后变化的部分抽象成了 HouseBuilder 基类。 House 类中则保留了除了这些内容之外的一些类的内容。

结构图

总结

Builder 生成器模式常用于”分步骤构建一个复杂的对象“。在这其中”分步骤“是一个稳定的算法，而复杂对象的各个部分是经常变化的。

其他设计模式汇总：
[设计模式] —— 设计模式的介绍及分类