3 生成器（Builder）模式

生成器模式

1.1 分类

（对象）创建型
1.2 提出题目

• 构造一个房屋，需要思量是否有车库，游泳池，花园，雕塑等，需要对诸多成员变量举行初始化工作。都写在构造函数里？每种大概都创建一个新的类？
  
• 相同的步骤需要能够产生差别的产物，例如使用木头和玻璃盖出来的是普通住房。用黄金和水晶制作出来的是宫殿。
  

1.3 办理方案

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建差别的表示。即将对象构造代码从产物类中抽取出来，并将其放在一个名为Builder的独立对象中。
1.4 实现类图

• 生成器（Builder）：声明通用的产物构造步骤。
  
• 详细生成器（Concrete Builders）：提供构造过程的差别实现。 详细生成器也可以构造不遵循通用接口的产物。
  
• 产物（Products）：最终生成的对象。由差别生成器构造的产物无需属于同一类层次结构或接口。
  
• 主管（Director）：定义调用构造步骤的顺序，如许你就可以创建和复用特定的产物设置。
  
• 客户端（Client）：必须将某个生成器对象与主管类关联。一 般情况下，只需通过主管类构造函数的参数举行一次性关联即可。
  

注：步伐中并不一定需要主管类。客户端代码可直接以特定顺序调用创建步骤。不过，主管类中非常适合放入各种例行构造流程，以便在步伐中反复使用。
注：差别于其他创造模式，差别的ConcreteBuilder可以生产不相关的产物。Product1和Product2可以不遵循相同的接口。因此在C++如许的静态范例语言中，getResult方法不能放到Builder接口里。
1.5 示例代码

1. #include <iostream>
2. #include <vector>
3. #include <string>
4. //产品1
5. class SimpleHouse {
6. public:
7.     std::vector<std::string> m_parts;
8.     void printParts() const {
9.         std::cout << "SimpleHouse 包括：\n";
10.         for (int i = 0; i < m_parts.size(); ++i) {
11.             std::cout << m_parts[i] << std::endl;
12.         }
13.         std::cout << "----------------------\n";
14.     }
15. };
16. //生成器
17. class Builder {
18. public:
19.     virtual ~Builder() {}
20.     virtual void reset() = 0;
21.     virtual void makeBaseHouse() = 0;
22.     virtual void makeGarage() = 0;
23.     virtual void makePool() = 0;
24. };
25. //concreteBuilder1，施工队
26. class SimpleHouseBuilder : public Builder {
27. private:
28.     SimpleHouse* m_simplehouse;
29. public:
30.     SimpleHouseBuilder() {
31.         reset();
32.     }
33.     ~SimpleHouseBuilder() { delete m_simplehouse; }
34.     void reset() override{
35.         m_simplehouse = new SimpleHouse();
36.     }
37.     virtual void makeBaseHouse() override{
38.         m_simplehouse->m_parts.push_back("BaseHouse");
39.     }
40.     virtual void makeGarage() override {
41.         m_simplehouse->m_parts.push_back("Garage");
42.     }
43.     virtual void makePool() override {
44.         m_simplehouse->m_parts.push_back("Pool");
45.     }
47.     SimpleHouse* getResult() {
48.         SimpleHouse* result = m_simplehouse;
49.         reset();
50.         return result;
51.     }
52. };
53. //主管：负责流程
54. class Director {
55. private:
56.     Builder* m_builder;
57. public:
58.     void setBuilder(Builder* builder) {
59.         m_builder = builder;
60.     }
61.     void makeSimpleHouse() {
62.         m_builder->makeBaseHouse();
63.         m_builder->makeGarage();
64.     }
65.     void makeFullFuncHouse() {
66.         m_builder->makeBaseHouse();
67.         m_builder->makeGarage();
68.         m_builder->makePool();
69.     }
70. };
71. //客户端（也可以封装成类）
72. void client(Director* director) {
73.     std::cout << "客户自己设计流程：---------------------\n";
74.     SimpleHouseBuilder* builder = new SimpleHouseBuilder();
75.     builder->makeBaseHouse();
76.     builder->makeGarage();
77.     SimpleHouse * simpleHouse= builder->getResult();
78.     simpleHouse->printParts();
79.     delete simpleHouse;
80.     std::cout << "主管负责设计流程：---------------------\n";
81.     director->setBuilder(builder);
82.     director->makeFullFuncHouse();
83.     simpleHouse = builder->getResult();
84.     simpleHouse->printParts();
85.     delete simpleHouse;
86.     delete builder;
87. }
88. int main()
89. {
90.     Director director;
91.     client(&director);
92. }

复制代码

1.6 举个栗子

下面关于生成器模式的例子，演示了怎样复用相同的对象构造代码来生成差别范例的产物：例如汽车（Car）和其相应的使用手册（Manual）。

1.7 总结

• 将对象的构造过程分解到多少个步骤，这就使步伐可以更加精细，有效地控制整个对象的构造。
  
• 生成差别形式的产物时，可以复用相同的制造代码。
  
• 单一职责原则。可以将复杂构造代码从产物的业务逻辑中分离出来。
  
• 当增加新的详细生成器时，不必修改主管的代码，满足开闭原则。
  
• 缺点：如果产物之间的差别性很大，则不适合使用制作者模式，使用范围受到一定的限定。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。