C++设计模式之建造者模式

在内蒙古这辽阔的草原上，放养着成千上万的奶牛。蒙牛集团在这里崛起，迅速抢占中国大半牛奶市场，造就了一个商业帝国。蒙牛集团牛奶生产流程大致是这样的: 放养奶牛--->牛奶加工--->牛奶包装--->销售。经历从放养奶牛到进行市场销售这一系列环节，蒙牛牛奶才得以诞生。虽然生产流程比这个流程还复杂，但对客户而言，根本不需要知道牛奶生产的细节，只需要到超市购买就行了。在设计模式中，也存在一个类似的模式，封装了产品创建的一系列操作过程，客户端无需知道这些操作流程就可以直接使用这个产品，称之为建造者模式。

1、建造者模式概述

    建造者模式是较为复杂的创建型模式，它将客户端与包含多个组成部分（或部件）的复杂对象的创建过程分离，客户端无须知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可。它关注如何一步一步创建一个的复杂对象，不同的具体建造者定义了不同的创建过程，且具体建造者相互独立，增加新的建造者非常方便，无须修改已有代码，系统具有较好的扩展性。例如:用户不需要知道电脑的具体制造流程，而直接使用电脑就可以了，电脑具体制造流程对用户来说就相当于一个黑盒子。

    建造者模式定义如下：

建造者模式(Builder Pattern)：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式是一种对象创建型模式。

    建造者模式一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

建造者模式结构图

    在建造者模式结构图中包含如下几个角色：

    Builder（抽象建造者）：它为创建一个产品Product对象的各个部件指定抽象接口，在该接口中一般声明两类方法，一类方法是buildPartX()，它们用于创建复杂对象的各个部件；另一类方法是getResult()，它们用于返回复杂对象。Builder既可以是抽象类，也可以是接口。

    ConcreteBuilder（具体建造者）：它实现了Builder接口，实现各个部件的具体构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象。

    Product（产品角色）：它是被构建的复杂对象，包含多个组成部件，具体建造者创建该产品的内部表示并定义它的装配过程。

    Director（指挥者）：指挥者又称为导演类，它负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。客户端一般只需要与指挥者进行交互，在客户端确定具体建造者的类型，并实例化具体建造者对象，然后通过指挥者类的构造函数或者Setter方法将该对象传入指挥者类中。

    在建造者模式的定义中提到了复杂对象，那么什么是复杂对象？简单来说，复杂对象是指那些包含多个成员属性的对象，这些成员属性也称为部件或零件，如汽车包括方向盘、发动机、轮胎等部件；电子邮件包括发件人、收件人、主题、内容、附件等部件；Socket数据包包含包头、包体、包尾等部件；XML配置文件包含头部信息、数据体、尾部信息等部件。

2、暴风影音播放器的设计与实现

    现需要开发一款类似暴风影音的播放器，该播放软件提供多种界面显示模式，如完整模式、精简模式、记忆模式等。在不同的显示模式下主界面的组成元素有所差异，如在完整模式下将显示菜单、播放列表、主窗口、控制条等；在精简模式下只显示主窗口和控制条；而在记忆模式下将显示主窗口、控制条、收藏列表等。尝试使用建造者模式设计该软件。

    暴风影音播放器是具体的产品，该产品包含菜单、主窗口、播放列表、播放进度条、收藏列表等部件。

    暴风影音播放器.h头文件代码如下:

[cpp]  view plain copy

1. #ifndef _PLAYER_H_  
2. #define _PLAYER_H_  
3. #include <iostream>  
4. #include <string>  
5. using namespace std;  
6.   
7. //播放器  
8. class Player  
9. {  
10. private:  
11.     string m_strMenu;           //菜单栏  
12.     string m_strWindow;         //主窗口  
13.     string m_strPlayList;           //播放列表  
14.     string m_strControlBar;         //进度条  
15.     string m_strCollectList;        //收藏列表  
16. public:  
17.     //设置部件  
18.     void SetMenu(string strMenu);  
19.     void SetWindow(string strWindow);  
20.     void SetPlayList(string strPlayList);  
21.     void SetControlBar(string strControlBar);  
22.     void SetCollectList(string strCollectList);  
23.   
24.     //获取各部件  
25.     string GetMenu();  
26.     string GetWindow();  
27.     string GetPlayList();  
28.     string GetControlBar();  
29.     string GetCollectList();  
30.   
31.     //显示播放器窗口包含的部件  
32.     void Display();  
33. };  
34.   
35. #endif  

     暴风影响播放器Cpp文件代码如下:

[cpp]  view plain copy

1. #include "Player.h"  
2.   
3. //设置主菜单部件  
4. void Player::SetMenu(string strMenu)  
5. {  
6.     m_strMenu = strMenu;  
7. }  
8.   
9. //设置主窗口部件  
10. void Player::SetWindow(string strWindow)  
11. {  
12.     m_strWindow = strWindow;  
13. }  
14.   
15. //设计播放列表部件  
16. void Player::SetPlayList(string strPlayList)  
17. {  
18.     m_strPlayList = strPlayList;  
19. }  
20.   
21. //设置滚动条部件  
22. void Player::SetControlBar(string strControlBar)  
23. {  
24.     m_strControlBar = strControlBar;  
25. }  
26.   
27. //设置收藏列表部件  
28. void Player::SetCollectList(string strCollectList)  
29. {  
30.     m_strCollectList = strCollectList;  
31. }  
32.   
33. //获取主菜单部件  
34. string Player::GetMenu()  
35. {  
36.     return m_strMenu;  
37. }  
38.   
39. //获取主窗口部件  
40. string Player::GetWindow()  
41. {  
42.     return m_strWindow;  
43. }  
44.   
45. //获取播放列表部件  
46. string Player::GetPlayList()  
47. {  
48.     return m_strPlayList;  
49. }  
50.   
51. //获取滚动条部件  
52. string Player::GetControlBar()  
53. {  
54.     return m_strControlBar;  
55. }  
56.   
57.   
58. //获取收藏列表部件  
59. string Player::GetCollectList()  
60. {  
61.     return m_strCollectList;  
62. }  
63.   
64. //显示播放器窗口包含的部件  
65. void Player::Display()  
66. {  
67.     cout << "---" << m_strWindow << endl;  
68.     cout << "---" << m_strMenu << endl;  
69.     cout << "---" << m_strPlayList << endl;  
70.     cout << "---" << m_strControlBar << endl;  
71.     cout << "---" << m_strCollectList << endl << endl;  
72. }  

    暴风影音播放器能在完整模式、精简模式、记忆模式三种模式下播放，各播放模式下，暴风影音的部件不相同。考虑到扩展性，可以定义一个抽象播放模式类，该抽象类中定义了一系列创建具体播放部件的方法。具体的三种播放模式继承于这个抽象播放模式类。

    播放模式.h头文件代码如下:

[cpp]  view plain copy

1. #ifndef _PLAY_PATTERN_H_  
2. #define _PLAY_PATTERN_H_  
3. #include <iostream>  
4. #include <string>  
5. #include "Player.h"  
6. using namespace std;  
7.   
8. //抽象播放模式  
9. class PlayPattern  
10. {  
11. protected:  
12.     //具体产品(播放器)  
13.     Player * m_pPlayer;  
14. public:  
15.     PlayPattern()  
16.     {  
17.         m_pPlayer = new Player();  
18.     }  
19.   
20.     ~PlayPattern()  
21.     {  
22.         if( NULL != m_pPlayer )  
23.         {  
24.             delete m_pPlayer;  
25.   
26.             m_pPlayer = NULL;  
27.         }  
28.     }  
29.       
30.     //制造播放窗口  
31.     virtual void BuildWindow() = 0;  
32.   
33.     //制造播放菜单  
34.     virtual void BuildMenu() = 0;  
35.   
36.     //制造播放列表  
37.     virtual void BuildPlayList() = 0;  
38.   
39.     //制造播放进度条  
40.     virtual void BuildControlBar() = 0;  
41.   
42.     //制造收藏列表  
43.     virtual void BuildCollectList() = 0;  
44.   
45.     //获取产品(播放器)  
46.     Player * GetPlayer()  
47.     {  
48.         return m_pPlayer;  
49.     }  
50. };  
51.   
52.   
53. //完整播放模式  
54. class FullPattern : public PlayPattern  
55. {  
56. public:  
57.     void BuildWindow();  
58.     void BuildMenu();  
59.     void BuildPlayList();  
60.     void BuildControlBar();  
61.     void BuildCollectList();  
62. };  
63.   
64.   
65. //精简播放模式  
66. class SimplePattern : public PlayPattern  
67. {  
68. public:  
69.     void BuildWindow();  
70.     void BuildMenu();  
71.     void BuildPlayList();  
72.     void BuildControlBar();  
73.     void BuildCollectList();  
74. };  
75.   
76.   
77. //记忆播放模式  
78. class MemoryPattern : public PlayPattern  
79. {  
80. public:  
81.     void BuildWindow();  
82.     void BuildMenu();  
83.     void BuildPlayList();  
84.     void BuildControlBar();  
85.     void BuildCollectList();  
86. };  
87.   
88. #endif  

     播放模式Cpp文件代码如下:

[cpp]  view plain copy

1. #include "PlayPattern.h"  
2.   
3. //制造播放窗口  
4. void FullPattern::BuildWindow()  
5. {  
6.     m_pPlayer->SetWindow("主界面窗口");  
7. }  
8.   
9. //制造播放菜单  
10. void FullPattern::BuildMenu()  
11. {  
12.     m_pPlayer->SetMenu("主菜单");  
13. }  
14.   
15. //制造播放列表  
16. void FullPattern::BuildPlayList()  
17. {  
18.     m_pPlayer->SetPlayList("播放列表");  
19. }  
20.   
21. //制造播放进度条  
22. void FullPattern::BuildControlBar()  
23. {  
24.     m_pPlayer->SetControlBar("进度条");  
25. }  
26.   
27. //制造收藏列表  
28. void FullPattern::BuildCollectList()  
29. {  
30.     m_pPlayer->SetCollectList(" ");  
31. }  
32.   
33. 精简模式///  
34.   
35. void SimplePattern::BuildWindow()  
36. {  
37.     m_pPlayer->SetWindow("主界面窗口");  
38. }  
39.   
40. void SimplePattern::BuildMenu()  
41. {  
42.     m_pPlayer->SetMenu(" ");  
43. }  
44.   
45. void SimplePattern::BuildPlayList()  
46. {  
47.     m_pPlayer->SetPlayList(" ");  
48. }  
49.   
50. void SimplePattern::BuildControlBar()  
51. {  
52.     m_pPlayer->SetControlBar("进度条");  
53. }  
54.   
55. void SimplePattern::BuildCollectList()  
56. {  
57.     m_pPlayer->SetCollectList(" ");  
58. }  
59.   
60. /记忆模式  
61.   
62. void MemoryPattern::BuildWindow()  
63. {  
64.     m_pPlayer->SetWindow("主界面窗口");  
65. }  
66.   
67. void MemoryPattern::BuildMenu()  
68. {  
69.     m_pPlayer->SetMenu(" ");  
70. }  
71.   
72. void MemoryPattern::BuildPlayList()  
73. {  
74.     m_pPlayer->SetPlayList(" ");  
75. }  
76.   
77. void MemoryPattern::BuildControlBar()  
78. {  
79.     m_pPlayer->SetControlBar("进度条");  
80. }  
81.   
82. void MemoryPattern::BuildCollectList()  
83. {  
84.     m_pPlayer->SetCollectList("收藏列表");  
85. }  

    在建造者模式的结构中还引入了一个指挥者类Director，用于控制产品的创建过程。本例中ContructManage就是播放器指挥类。用户需要哪种类型的播放模式，只需要创建一个具体的播放模式，然后把这个播放模式传入到播放器指挥者中就可以了，由播放器指挥者处理一系列过程的建造。
    暴风影音播放器指挥者类.h头文件实现如下：

[cpp]  view plain copy

1. #ifndef _CONTRUCT_MANAGE_H_  
2. #define _CONTRUCT_MANAGE_H_  
3. #include "PlayPattern.h"  
4. #include "Player.h"  
5.   
6. //建造管理器  
7. class ContructManage  
8. {  
9. private:  
10.     //具体建造者  
11.     PlayPattern * m_pPlayPattern;  
12. public:  
13.     //设置播放模式  
14.     void SetPlayPattern(PlayPattern * pPlayPattern);  
15.   
16.     //封装建造过程  
17.     Player * Construct();  
18. };  
19.   
20. #endif  

     暴风影音播放器指挥者类Cpp文件实现如下：

[cpp]  view plain copy

1. #include "ContructManage.h"  
2.   
3. //设置播放模式  
4. void ContructManage::SetPlayPattern(PlayPattern * pPlayPattern)  
5. {  
6.     m_pPlayPattern = pPlayPattern;  
7. }  
8.   
9. //封装建造过程  
10. Player * ContructManage::Construct()  
11. {  
12.     m_pPlayPattern->BuildWindow();  
13.     m_pPlayPattern->BuildMenu();  
14.     m_pPlayPattern->BuildPlayList();  
15.     m_pPlayPattern->BuildControlBar();  
16.     m_pPlayPattern->BuildCollectList();  
17.   
18.     Player * pPlayer = m_pPlayPattern->GetPlayer();  
19.     return pPlayer;  
20. }  

    测试文件实现代码如下:

[cpp]  view plain copy

1. #include <iostream>  
2. #include "ContructManage.h"  
3. #include "PlayPattern.h"  
4. #include "Player.h"  
5. using namespace std;  
6.   
7. int main()  
8. {  
9.         /***********************创建建造管理器**********************/  
10.     ContructManage * pContructManage = new ContructManage();  
11.     Player * pPlayer = NULL;  
12.   
13.     /***********************完整播放模式************************/  
14.     PlayPattern * pFullPattern = new FullPattern();  
15.     cout << "完整播放模式:" << endl;  
16.     pContructManage->SetPlayPattern(pFullPattern);  
17.     pPlayer = pContructManage->Construct();  
18.     pPlayer->Display();  
19.   
20.     /***********************精简播放模式************************/  
21.     PlayPattern * pSimplePattern = new SimplePattern();  
22.     cout << "精简播放模式:" << endl;  
23.     pContructManage->SetPlayPattern(pSimplePattern);  
24.     pPlayer = pContructManage->Construct();  
25.     pPlayer->Display();  
26.   
27.     /***********************记忆播放模式************************/  
28.     PlayPattern * pMemoryPattern = new MemoryPattern();  
29.     cout << "记忆播放模式:" << endl;  
30.     pContructManage->SetPlayPattern(pMemoryPattern);  
31.     pPlayer = pContructManage->Construct();  
32.     pPlayer->Display();  
33.   
34.     /***********************销毁操作****************************/  
35.     cout << endl;  
36.     delete pFullPattern;  
37.     pFullPattern = NULL;  
38.   
39.     delete pSimplePattern;  
40.     pSimplePattern = NULL;  
41.   
42.     delete pMemoryPattern;  
43.     pMemoryPattern = NULL;  
44.   
45.     delete pContructManage;  
46.     pContructManage = NULL;  
47.   
48.     return 0;  
49. }  

编译并执行，程序结果如下:

    在建造者模式中，客户端只需实例化指挥者类，指挥者类针对抽象建造者编程，客户端根据需要传入具体的建造者类型，指挥者将指导具体建造者一步一步构造一个完整的产品（逐步调用具体建造者的buildX()方法），相同的构造过程可以创建完全不同的产品。在暴风影音播放器实例中，如果需要更换具体的播放模式，只需要把具体播放模式传入到播放器指挥者中即可，可以随时切换播放模式；如果需要增加新的播放模式，可以增加一个新的播放模式类作为抽象播放模式子类，并把该播放模式传入到播放器指挥者中，原有代码无须修改，完全符合“开闭原则”。

3、省略指挥者Director的建造者模式

    指挥者类Director在建造者模式中扮演非常重要的作用，简单的Director类用于指导具体建造者如何构建产品，它按一定次序调用Builder的buildPartX()方法，控制调用的先后次序，并向客户端返回一个完整的产品对象。Direcotr针对抽象的建造者进行编程，如果需要不同的建造者，只需把建造者传入指挥者类，无需修改之前的代码。

    在有些情况下，为了简化系统结构，可以省略指挥者Director，指挥者不再指导产品的创建过程。而是在Builder中提供逐步构建复杂产品对象的construct()方法。

    暴风影音播放器是具体的产品，实现代码和上一篇博客一样，这里就不再呈现。有变化的是建造者类，播放模式.h头文件实现代码如下:

[cpp]  view plain copy

1. #ifndef _PLAY_PATTERN_H_  
2. #define _PLAY_PATTERN_H_  
3. #include <iostream>  
4. #include <string>  
5. #include "Player.h"  
6. using namespace std;  
7.   
8. //抽象播放模式  
9. class PlayPattern  
10. {  
11. protected:  
12.     //具体产品(播放器)  
13.     Player * m_pPlayer;  
14. public:  
15.     PlayPattern()  
16.     {  
17.         m_pPlayer = new Player();  
18.     }  
19.   
20.     ~PlayPattern()  
21.     {  
22.         if( NULL != m_pPlayer )  
23.         {  
24.             delete m_pPlayer;  
25.   
26.             m_pPlayer = NULL;  
27.         }  
28.     }  
29.       
30.     //制造播放窗口  
31.     virtual void BuildWindow() = 0;  
32.   
33.     //制造播放菜单  
34.     virtual void BuildMenu() = 0;  
35.   
36.     //制造播放列表  
37.     virtual void BuildPlayList() = 0;  
38.   
39.     //制造播放进度条  
40.     virtual void BuildControlBar() = 0;  
41.   
42.     //制造收藏列表  
43.     virtual void BuildCollectList() = 0;  
44.   
45.     //开始建造，封装建造过程  
46.     Player * StartConstruct()  
47.     {  
48.         BuildWindow();  
49.         BuildMenu();  
50.         BuildPlayList();  
51.         BuildControlBar();  
52.         BuildCollectList();  
53.           
54.         return m_pPlayer;  
55.     }  
56. };  
57.   
58.   
59. //完整播放模式  
60. class FullPattern : public PlayPattern  
61. {  
62. public:  
63.     void BuildWindow();  
64.     void BuildMenu();  
65.     void BuildPlayList();  
66.     void BuildControlBar();  
67.     void BuildCollectList();  
68. };  
69.   
70.   
71. //精简播放模式  
72. class SimplePattern : public PlayPattern  
73. {  
74. public:  
75.     void BuildWindow();  
76.     void BuildMenu();  
77.     void BuildPlayList();  
78.     void BuildControlBar();  
79.     void BuildCollectList();  
80. };  
81.   
82.   
83. //记忆播放模式  
84. class MemoryPattern : public PlayPattern  
85. {  
86. public:  
87.     void BuildWindow();  
88.     void BuildMenu();  
89.     void BuildPlayList();  
90.     void BuildControlBar();  
91.     void BuildCollectList();  
92. };  
93.   
94. #endif  

    指导者类不再指导暴风影音产品对象的创建过程，而是由抽象播放器模式StartConstruct方法来封装播放器产品的创建过程。
    播放模式Cpp文件代码如下:

[cpp]  view plain copy

1. #include "PlayPattern.h"  
2.   
3. //制造播放窗口  
4. void FullPattern::BuildWindow()  
5. {  
6.     m_pPlayer->SetWindow("主界面窗口");  
7. }  
8.   
9. //制造播放菜单  
10. void FullPattern::BuildMenu()  
11. {  
12.     m_pPlayer->SetMenu("主菜单");  
13. }  
14.   
15. //制造播放列表  
16. void FullPattern::BuildPlayList()  
17. {  
18.     m_pPlayer->SetPlayList("播放列表");  
19. }  
20.   
21. //制造播放进度条  
22. void FullPattern::BuildControlBar()  
23. {  
24.     m_pPlayer->SetControlBar("进度条");  
25. }  
26.   
27. //制造收藏列表,完整播放模式没有收藏列表，内容设为空  
28. void FullPattern::BuildCollectList()  
29. {  
30.     m_pPlayer->SetCollectList(" ");  
31. }  
32.   
33. 精简模式///  
34.   
35. void SimplePattern::BuildWindow()  
36. {  
37.     m_pPlayer->SetWindow("主界面窗口");  
38. }  
39.   
40. void SimplePattern::BuildMenu()  
41. {  
42.     m_pPlayer->SetMenu(" ");  
43. }  
44.   
45. void SimplePattern::BuildPlayList()  
46. {  
47.     m_pPlayer->SetPlayList(" ");  
48. }  
49.   
50. void SimplePattern::BuildControlBar()  
51. {  
52.     m_pPlayer->SetControlBar("进度条");  
53. }  
54.   
55. void SimplePattern::BuildCollectList()  
56. {  
57.     m_pPlayer->SetCollectList(" ");  
58. }  
59.   
60. /记忆模式  
61.   
62. void MemoryPattern::BuildWindow()  
63. {  
64.     m_pPlayer->SetWindow("主界面窗口");  
65. }  
66.   
67. void MemoryPattern::BuildMenu()  
68. {  
69.     m_pPlayer->SetMenu(" ");  
70. }  
71.   
72. void MemoryPattern::BuildPlayList()  
73. {  
74.     m_pPlayer->SetPlayList(" ");  
75. }  
76.   
77. void MemoryPattern::BuildControlBar()  
78. {  
79.     m_pPlayer->SetControlBar("进度条");  
80. }  
81.   
82. void MemoryPattern::BuildCollectList()  
83. {  
84.     m_pPlayer->SetCollectList("收藏列表");  
85. }  

    完整播放模式下并不需要建造收藏列表部件，因此把收藏列表的内容设为空，其它情况类型，把不需要建造的部件内容设为空。测试程序实现代码如下：

[cpp]  view plain copy

1. #include <iostream>  
2. #include "PlayPattern.h"  
3. #include "Player.h"  
4.   
5. using namespace std;  
6.   
7. int main()  
8. {  
9.     Player * pPlayer = NULL;  
10.   
11.     /***********************完整播放模式************************/  
12.     PlayPattern * pFullPattern = new FullPattern();  
13.     cout << "完整播放模式:" << endl;  
14.     pPlayer = pFullPattern->StartConstruct();  
15.     pPlayer->Display();  
16.   
17.     /***********************精简播放模式************************/  
18.     SimplePattern * pSimplePattern = new SimplePattern();  
19.     cout << "精简播放模式:" << endl;  
20.     pPlayer = pSimplePattern->StartConstruct();  
21.     pPlayer->Display();  
22.    
23.     /***********************记忆播放模式************************/  
24.     MemoryPattern * pMemoryPattern = new MemoryPattern();  
25.     cout << "记忆播放模式:" << endl;  
26.     pPlayer = pMemoryPattern->StartConstruct();  
27.     pPlayer->Display();  
28.   
29.     /***********************销毁操作****************************/  
30.     cout << endl;  
31.     delete pFullPattern;  
32.     pFullPattern = NULL;  
33.   
34.     delete pSimplePattern;  
35.     pSimplePattern = NULL;  
36.   
37.     delete pMemoryPattern;  
38.     pMemoryPattern = NULL;  
39.   
40.     return 0;  
41. }  

    编译并执行，结果如下：

    此时，StartConstruct()方法定义了其他buildPartX()方法调用的次序，为其他方法的执行提供了一个流程模板，这与我们在后面要学习的模板方法模式非常类似。对Director类的省略方式都不影响系统的灵活性和可扩展性，同时还简化了系统结构，但加重了抽象建造者类的职责，如果StartConstruct()方法较为复杂，待构建产品的组成部分较多，建议还是将StartConstruct()方法单独封装在Director中，这样做更符合“单一职责原则”

4、引入钩子方法的建造者模式

    建造者模式除了逐步构建一个复杂产品对象外，还可以通过Director类来更加精细地控制产品的创建过程，例如增加一类称之为钩子方法(HookMethod)的特殊方法来控制是否对某个buildPartX()的调用，也就是判断产品中某个部件是否需要被建造。钩子方法的返回类型通常为boolean类型，方法名一般为isXXX()，钩子方法定义在抽象建造者类中。在抽象建造者类中提供钩子方法的默认实现，具体建造者类如果不需要建造某个部件，则该建造者类覆盖抽象建造者类的钩子方法。

    暴风影音播放器是具体的产品，实现代码和C++设计模式之建造者模式(一)博客一样，这里就不再呈现。而抽象播放器模式类中定义了一系列的钩子方法，并提供了默认的实现，用于判断是否需要创建对应的部件。如果具体播放器模式不需要某个部件，则具体播放器模式覆盖对应的钩子方法。

    播放模式.h头文件代码如下:

[cpp]  view plain copy

1. #ifndef _PLAY_PATTERN_H_  
2. #define _PLAY_PATTERN_H_  
3. #include <iostream>  
4. #include <string>  
5. #include "Player.h"  
6. using namespace std;  
7.   
8. //抽象播放模式  
9. class PlayPattern  
10. {  
11. protected:  
12.     //具体产品(播放器)  
13.     Player * m_pPlayer;  
14. public:  
15.     PlayPattern()  
16.     {  
17.         m_pPlayer = new Player();  
18.     }  
19.   
20.     ~PlayPattern()  
21.     {  
22.         if( NULL != m_pPlayer )  
23.         {  
24.             delete m_pPlayer;  
25.   
26.             m_pPlayer = NULL;  
27.         }  
28.     }  
29.       
30.     //制造播放窗口  
31.     virtual void BuildWindow() = 0;  
32.   
33.     //制造播放菜单  
34.     virtual void BuildMenu() = 0;  
35.   
36.     //制造播放列表  
37.     virtual void BuildPlayList() = 0;  
38.   
39.     //制造播放进度条  
40.     virtual void BuildControlBar() = 0;  
41.   
42.     //制造收藏列表  
43.     virtual void BuildCollectList() = 0;  
44.   
45.     //获取产品(播放器)  
46.     Player * GetPlayer()  
47.     {  
48.         return m_pPlayer;  
49.     }  
50.   
51.     //是否建造播放窗口（钩子方法）  
52.     virtual bool IsBuildWindow()  
53.     {  
54.         return true;  
55.     }  
56.       
57.     //是否建造播放菜单（钩子方法）  
58.     virtual bool IsBuildMenu()  
59.     {  
60.         return true;  
61.     }  
62.   
63.     //是否建造播放列表（钩子方法）  
64.     virtual bool IsBuildPlayList()  
65.     {  
66.         return true;  
67.     }  
68.   
69.     //是否建造播放进度条（钩子方法）  
70.     virtual bool IsBuildControlBar()  
71.     {  
72.         return true;  
73.     }  
74.   
75.     //是否建造收藏列表（钩子方法）  
76.     virtual bool IsBuildCollectList()  
77.     {  
78.         return true;  
79.     }  
80. };  
81.   
82.   
83. //完整播放模式  
84. class FullPattern : public PlayPattern  
85. {  
86. public:  
87.     void BuildWindow();  
88.     void BuildMenu();  
89.     void BuildPlayList();  
90.     void BuildControlBar();  
91.     void BuildCollectList();  
92.   
93.     //完整播放模式不需要建造收藏列表  
94.     bool IsBuildCollectList()  
95.     {  
96.         return false;  
97.     }  
98. };  
99.   
100.   
101. //精简播放模式  
102. class SimplePattern : public PlayPattern  
103. {  
104. public:  
105.     void BuildWindow();  
106.     void BuildMenu();  
107.     void BuildPlayList();  
108.     void BuildControlBar();  
109.     void BuildCollectList();  
110.   
111.     //精简播放模式不需要建造播放菜单  
112.     bool IsBuildMenu()  
113.     {  
114.         return false;  
115.     }  
116.   
117.     //精简播放模式不需要建造播放列表  
118.     bool IsBuildPlayList()  
119.     {  
120.         return false;  
121.     }  
122.   
123.     //精简播放模式不需要建造收藏列表  
124.     bool IsBuildCollectList()  
125.     {  
126.         return false;  
127.     }  
128. };  
129.   
130.   
131.   
132. //记忆播放模式  
133. class MemoryPattern : public PlayPattern  
134. {  
135. public:  
136.     void BuildWindow();  
137.     void BuildMenu();  
138.     void BuildPlayList();  
139.     void BuildControlBar();  
140.     void BuildCollectList();  
141.   
142.     //记忆播放模式不需要建造播放菜单  
143.     bool IsBuildMenu()  
144.     {  
145.         return false;  
146.     }  
147.       
148.     //记忆播放模式不需要建造播放列表  
149.     bool IsBuildPlayList()  
150.     {  
151.         return false;  
152.     }  
153. };  
154.   
155. #endif  

    播放器模式Cpp实现代码如下:

[cpp]  view plain copy

1. #include "PlayPattern.h"  
2.   
3. //制造播放窗口  
4. void FullPattern::BuildWindow()  
5. {  
6.     m_pPlayer->SetWindow("主界面窗口");  
7. }  
8.   
9.   
10. //制造播放菜单  
11. void FullPattern::BuildMenu()  
12. {  
13.     m_pPlayer->SetMenu("主菜单");  
14. }  
15.   
16.   
17. //制造播放列表  
18. void FullPattern::BuildPlayList()  
19. {  
20.     m_pPlayer->SetPlayList("播放列表");  
21. }  
22.   
23.   
24. //制造播放进度条  
25. void FullPattern::BuildControlBar()  
26. {  
27.     m_pPlayer->SetControlBar("进度条");  
28. }  
29.   
30.   
31. //制造收藏列表  
32. void FullPattern::BuildCollectList()  
33. {  
34.     m_pPlayer->SetCollectList(" ");  
35. }  
36.   
37.   
38. 精简模式///  
39.   
40. void SimplePattern::BuildWindow()  
41. {  
42.     m_pPlayer->SetWindow("主界面窗口");  
43. }  
44.   
45.   
46. void SimplePattern::BuildMenu()  
47. {  
48.     m_pPlayer->SetMenu(" ");  
49. }  
50.   
51.   
52. void SimplePattern::BuildPlayList()  
53. {  
54.     m_pPlayer->SetPlayList(" ");  
55. }  
56.   
57.   
58. void SimplePattern::BuildControlBar()  
59. {  
60.     m_pPlayer->SetControlBar("进度条");  
61. }  
62.   
63.   
64. void SimplePattern::BuildCollectList()  
65. {  
66.     m_pPlayer->SetCollectList(" ");  
67. }  
68.   
69. /记忆模式  
70.   
71. void MemoryPattern::BuildWindow()  
72. {  
73.     m_pPlayer->SetWindow("主界面窗口");  
74. }  
75.   
76.   
77. void MemoryPattern::BuildMenu()  
78. {  
79.     m_pPlayer->SetMenu(" ");  
80. }  
81.   
82.   
83. void MemoryPattern::BuildPlayList()  
84. {  
85.     m_pPlayer->SetPlayList(" ");  
86. }  
87.   
88.   
89. void MemoryPattern::BuildControlBar()  
90. {  
91.     m_pPlayer->SetControlBar("进度条");  
92. }  
93.   
94. void MemoryPattern::BuildCollectList()  
95. {  
96.     m_pPlayer->SetCollectList("收藏列表");  
97. }  

    在暴风影音播放器指导者ContructManage中，调用了一系列的钩子方法，用于判断在不同播放模式下，是否需要创建对应的部件。暴风影音播放器指挥者类.h头文件实现如下：

[cpp]  view plain copy

1. #ifndef _CONTRUCT_MANAGE_H_  
2. #define _CONTRUCT_MANAGE_H_  
3. #include "PlayPattern.h"  
4. #include "Player.h"  
5.   
6. //建造管理器  
7. class ContructManage  
8. {  
9. private:  
10.     //具体建造者  
11.     PlayPattern * m_pPlayPattern;  
12. public:  
13.     //设计播放器模式(也就是设置具体建造者)  
14.     void SetPlayPattern(PlayPattern * pPlayPattern);  
15.   
16.     //封装建造过程，调用钩子方法，判断对应的部件是否需要建造  
17.     Player * Construct();  
18. };  
19.   
20. #endif  

    暴风影音播放器指挥者类Cpp文件实现如下：

[cpp]  view plain copy

1. #include "ContructManage.h"  
2.   
3. //设计播放器模式(也就是设置具体建造者)  
4. void ContructManage::SetPlayPattern(PlayPattern * pPlayPattern)  
5. {  
6.     m_pPlayPattern = pPlayPattern;  
7. }  
8.   
9.   
10. //封装建造过程，调用一系列钩子方法，判断对应的部件是否需要建造  
11. Player * ContructManage::Construct()  
12. {  
13.     bool bRetVal = true;  
14.   
15.     //根据需要建造播放窗口  
16.     bRetVal = m_pPlayPattern->IsBuildWindow();  
17.   
18.     if( true == bRetVal )  
19.     {  
20.         m_pPlayPattern->BuildWindow();  
21.     }  
22.       
23.     //根据需要建造播放菜单  
24.     bRetVal = m_pPlayPattern->IsBuildMenu();  
25.   
26.     if( true == bRetVal )  
27.     {  
28.         m_pPlayPattern->BuildMenu();  
29.     }  
30.       
31.     //根据需要建造播放列表  
32.     bRetVal = m_pPlayPattern->IsBuildPlayList();  
33.   
34.     if( true == bRetVal )  
35.     {  
36.         m_pPlayPattern->BuildPlayList();  
37.     }  
38.       
39.     //根据需要建造播放进度条  
40.     bRetVal = m_pPlayPattern->IsBuildControlBar();  
41.   
42.     if( true == bRetVal )  
43.     {  
44.         m_pPlayPattern->BuildControlBar();  
45.     }  
46.       
47.     //根据需要建造收藏列表  
48.     bRetVal = m_pPlayPattern->IsBuildCollectList();  
49.   
50.     if( true == bRetVal )  
51.     {     
52.         m_pPlayPattern->BuildCollectList();  
53.     }  
54.       
55.     //返回已经建造好的播放器  
56.     Player * pPlayer = m_pPlayPattern->GetPlayer();  
57.   
58.     return pPlayer;  
59. }  

   测试程序实现代码如下：

[cpp]  view plain copy

1. #include <iostream>  
2. #include "ContructManage.h"  
3. #include "PlayPattern.h"  
4. #include "Player.h"  
5.   
6. using namespace std;  
7.   
8. int main()  
9. {  
10.         /***********************创建建造管理器**********************/  
11.     ContructManage * pContructManage = new ContructManage();  
12.     Player * pPlayer = NULL;  
13.   
14.     /***********************完整播放模式************************/  
15.     PlayPattern * pFullPattern = new FullPattern();  
16.     cout << "完整播放模式:" << endl;  
17.     pContructManage->SetPlayPattern(pFullPattern);  
18.     pPlayer = pContructManage->Construct();  
19.     pPlayer->Display();  
20.   
21.     /***********************精简播放模式************************/  
22.     PlayPattern * pSimplePattern = new SimplePattern();  
23.     cout << "精简播放模式:" << endl;  
24.     pContructManage->SetPlayPattern(pSimplePattern);  
25.     pPlayer = pContructManage->Construct();  
26.     pPlayer->Display();  
27.   
28.     /***********************记忆播放模式************************/  
29.     PlayPattern * pMemoryPattern = new MemoryPattern();  
30.     cout << "记忆播放模式:" << endl;  
31.     pContructManage->SetPlayPattern(pMemoryPattern);  
32.     pPlayer = pContructManage->Construct();  
33.     pPlayer->Display();  
34.   
35.     /***********************销毁操作****************************/  
36.     cout << endl;  
37.     delete pFullPattern;  
38.     pFullPattern = NULL;  
39.   
40.     delete pSimplePattern;  
41.     pSimplePattern = NULL;  
42.   
43.     delete pMemoryPattern;  
44.     pMemoryPattern = NULL;  
45.   
46.     delete pContructManage;  
47.     pContructManage = NULL;  
48.   
49.     return 0;  
50. }  

    编译并执行，结果如下：

    通过引入钩子方法，我们可以在建造者指导者类中对复杂产品的构建进行精细的控制，不仅指定buildPartX()方法的执行顺序，还可以控制是否需要执行某个buildPartX()方法。

5、建造者模式总结

    建造者模式的核心在于如何一步步构建一个包含多个组成部件的完整对象，使用相同的构建过程构建不同的产品，在软件开发中，如果我们需要创建复杂对象并希望系统具备很好的灵活性和可扩展性可以考虑使用建造者模式。

1.主要优点

    建造者模式的主要优点如下：

    (1) 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。建造者模式封装了产品具体的创建流程，符合"封装变化原则"。

    (2) 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。由于指挥者类针对抽象建造者编程，增加新的具体建造者无须修改原有类库的代码，系统扩展方便，符合“开闭原则”，也符合"针对抽象进行编程而不是针对具体编程原则"。

    (3) 可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

2.主要缺点

    建造者模式的主要缺点如下：

    (1) 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，例如很多组成部分都不相同，不适合使用建造者模式，因此其使用范围受到一定的限制。

    (2) 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，增加系统的理解难度和运行成本。

3.建造者模式的具体应用

    (1)在游戏角色中，存在魔鬼、天使、英雄等角色。这些角色都包含相同的建造过程(建造头、脚、外观等)，而每一个游戏角色建造方法各不相同。

    (2)解析XML格式的配置文件时，需要解析配置文件的头部信息、数据体、尾部信息等。可以把解析的三个过程视为建造的三个过程。

    (3)解析Rtf文档格式同样存在和解析XML格式的配置文件相同的情况。

    (4)我们使用Email发送邮件的是否，需要填写邮件标题、收件人、邮件内容等信息。可以把填写邮件标题、收件人、邮件内容视为三个建造过程。

    (5)我们在定义Socket网络通信协议的时候，需要定义数据祯，每祯由包头、包体、包尾组成。这样在通信的双方，就可以按照同样的格式进行收发信息。

    (6)使用Gcc编译程序需要经历编译、汇编、链接等过程，最终才能形成可执行程序。

    (7)我们使用美图、Photoshop软件美化图像时，得执行一系列操作(锐化、镜像等)，最终才有一副绚丽的照片。

    (8)在创建对话框程序过程中，会有一个向导提示每一步的创建过程。经历一系列的过程，最终才形成一个对话框。同样，在安装软件的过程中，也会出现向导让我们定制软件的某些外观或者功能。

    (9)在定制Linux内核过程中，可以根据需要删减某些不需要的功能模块。定制出一个功能适中的操作系统，俗称内核裁剪，然后把裁剪后的Linux系统移植到嵌入式设备上(ARM等)。

    (10)生活中的建造者模式应用: 桥梁建造、三峡工程建造、鸟巢水立方等一系列工程建造；361、安踏、九牧王一系列服装业建造；杂交水稻、转基因大米等粮食建造。