设计模式-Builder

动机

• 在软件系统中，有时候面临着”一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求变化，这个复杂对象的各个部分经常面临这剧烈变化，但是将他们组合在一起的算法却相对稳定。
• 如何提供一种封装机制来隔离出复杂对象各个部分的变化，从而保持系统中的稳定构建算法不随着需求改变而改变。

思路

• 基类负责构造流程，子类负责各个部分构造的具体实现
• 这种思想和模板方法非常接近，只不过是专门用于构造对象的

版本一：使用模板方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class House{
public:
    virtual ~House() {}
    void init() {
        //管理构造流程
        BuildPart1();
        for (int i = 0; i < 4; i++){
            BuildPart2();
        }
        bool flag=BuildPart3();
        if(flag){
            BuildPart4();
        }
        BuildPart5();
    }
protected:
	virtual void BuildPart1()=0;
    virtual void BuildPart2()=0;
    virtual void BuildPart3()=0;
    virtual void BuildPart4()=0;
    virtual void BuildPart5()=0;
};

1
2
3
4
5
6
7
8
9
10

class StoneHouse: public House{
public:
protected:
    //实现具体的构造步骤
    virtual void BuildPart1(){}
    virtual void BuildPart2(){}
    virtual void BuildPart3(){}
    virtual void BuildPart4(){}
    virtual void BuildPart5(){}
};

1
2
3
4
5

int main()
{
    House* phouse = new StoneHouse();
    phouse->init();
}

版本二：进一步拆分

• product成员复杂
• 构建流程管理与构建具体实现不想与product其他成员混在一起
  product类

  builder基类

  director类

  product子类

  builder子类

  客户程序

  1 2	class House{ }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  class HouseBuilder { public: House* GetResult(){ return pHouse; } virtual ~HouseBuilder(){} protected: House* pHouse; virtual void BuildPart1()=0; virtual void BuildPart2()=0; virtual void BuildPart3()=0; virtual void BuildPart4()=0; virtual void BuildPart5()=0; };

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  class HouseDirector{ public: HouseDirector(HouseBuilder* pHouseBuilder) ： pHouseBuilder(pHouseBuilder){} House* Construct(){ pHouseBuilder->BuildPart1(); for (int i = 0; i < 4; i++){ pHouseBuilder->BuildPart2(); } bool flag=pHouseBuilder->BuildPart3(); if(flag){ pHouseBuilder->BuildPart4(); } pHouseBuilder->BuildPart5(); return pHouseBuilder->GetResult(); } private: HouseBuilder* pHouseBuilder; };

  1 2	class StoneHouse: public House{ };

  1 2 3 4 5 6 7 8

  class StoneHouseBuilder: public HouseBuilder{ protected: virtual void BuildPart1(){} virtual void BuildPart2(){} virtual void BuildPart3(){} virtual void BuildPart4(){} virtual void BuildPart5(){} };

  1 2 3 4 5 6

  int main() { HouseBuilder* pHouseBuilder = new StoneHouseBuilder(); HouseDirector * pHouseDirector = new HouseDirector(pHouseBuilder); House* pHouse = pHouseDirector->Construct(); }

• 其中House和HouseBuilder均属于抽象基类，且一一对应

总结

• 类图

• Builder模式主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。
• 变化点在哪里，封装在哪里：Builder模式主要在于应对“负载对象各个部分”的频繁需求变动；其缺点在于难以应对“分步骤”构建算法的需求变动。
• 在Builder模式中，要注意不同语言中构造器内调用虚函数的差别。