读《大话设计模式》－－－外观模式(Facade)

外观模式:

为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得一个子系统更加容易使用

 

外观模式结构图

 

外观模式的一般实现方法：

1. #include <iostream>
2. using namespace std;
4. class SubSystemOne
5. {
6. public:
7.     void MethodOne()
8.     {
9.         cout << " 子系统方法一" << endl;
10.     }
11. };
12. class SubSystemTwo
13. {
14. public:
15.     void MethodTwo()
16.     {
17.         cout << " 子系统方法二" << endl;
18.     }
19. };
20. class SubSystemThree
21. {
22. public:
23.     void MethodThree()
24.     {
25.         cout << " 子系统方法三" << endl;
26.     }
27. };
28. class SubSystemFour
29. {
30. public:
31.     void MethodFour()
32.     {
33.         cout << " 子系统方法四" << endl;
34.     }
35. };
36. //外观类，它需要了解所有子系统的方法和属性，进行组合，以备外界使用。
37. class Facade
38. {
39. private:
40.     SubSystemOne * one;
41.     SubSystemTwo * two;
42.     SubSystemThree * three;
43.     SubSystemFour * four;
45. public:
46.     Facade()
47.     {
48.         one = new SubSystemOne();
49.         two = new SubSystemTwo();
50.         three = new SubSystemThree();
51.         four = new SubSystemFour();
52.     }
53.     ~Facade()
54.     {
55.         delete one;
56.         delete two;
57.         delete three;
58.         delete four;
59.     }
60.     void MethodA()
61.     {
62.         cout << "/n方法组A() ---- " << endl;
63.         one->MethodOne();
64.         two->MethodTwo();
65.         four->MethodFour();
66.     }
67.     
68.     void MethodB()
69.     {
70.         cout << "/n方法组B() ---- " << endl;
71.         two->MethodTwo();
72.         three->MethodThree();
73.     }
74. };
76. //由于Facade的存在，客户端根本不需要知道子系统的存在
77. int main()
78. {
79.     Facade * facade = new Facade();
80.     facade->MethodA();
81.     facade->MethodB();
82.     delete facade;
83.     return 0;
84. }

Facade模式的具体实现

1. //投资基金代码
3. #include <iostream>
4. using namespace std;
6. //股票1
7. class Stock1
8. {
9.     //卖股票
10. public: 
11.     void Sell()
12.     {
13.         cout << " 股票1卖出" << endl;
14.     }
15.     
16.     //买股票
17.     void Buy()
18.     {
19.         cout << " 股票1买入" << endl;
20.     }
21. };
23. //股票2
24. class Stock2
25. {
26.     //卖股票
27. public:
28.     void Sell()
29.     {
30.         cout << " 股票2卖出" << endl;
31.     }
32.     
33.     //买股票
34.     void Buy()
35.     {
36.         cout << " 股票2买入" << endl;
37.     }
38. };
40. //股票3
41. class Stock3
42. {
43.     //卖股票
44. public:
45.     void Sell()
46.     {
47.         cout << " 股票3卖出" << endl;
48.     }
49.     
50.     //买股票
51.     void Buy()
52.     {
53.         cout << " 股票3买入" << endl;
54.     }
55. };
57. //国债1
58. class NationalDebt1
59. {
60.     //卖国债
61. public:
62.     void Sell()
63.     {
64.         cout << " 国债1卖出" << endl;
65.     }
66.     
67.     //买国债
68.     void Buy()
69.     {
70.         cout << " 国债1买入" << endl;
71.     }
72. };
74. //房地产1
75. class Realty1
76. {
77.     //卖房地产
78. public:
79.     void Sell()
80.     {
81.         cout << " 房产1卖出" << endl;
82.     }
83.     
84.     //买房地产
85.     void Buy()
86.     {
87.         cout << " 房产1买入" << endl;
88.     }
89. };
91. class Fund
92. {
93. private:
94.     Stock1 * gu1;
95.     Stock2 * gu2;
96.     Stock3 * gu3;
97.     NationalDebt1 * nd1;
98.     Realty1 * rt1;
99.     
100. public:
101.     Fund()
102.     {
103.         gu1 = new Stock1();
104.         gu2 = new Stock2();
105.         gu3 = new Stock3();
106.         nd1 = new NationalDebt1();
107.         rt1 = new Realty1();
108.     }
109.     ~Fund()
110.     {
111.         delete gu1;
112.         delete gu2;
113.         delete gu3;
114.         delete nd1;
115.         delete rt1;
116.     }
117.     void BuyFund()
118.     {
119.         gu1->Buy();
120.         gu2->Buy();
121.         gu3->Buy();
122.         nd1->Buy();
123.         rt1->Buy();
124.     }
125.     void SellFund()
126.     {
127.         gu1->Sell();
128.         gu2->Sell();
129.         gu3->Sell();
130.         nd1->Sell();
131.         rt1->Sell();
132.     }
133. };
135. int main()
136. {
137.     Fund * fund = new Fund();
138.     
139.     fund->BuyFund();
140.     fund->SellFund();
141.     
142.     delete fund;
143.     return 0;
144. }

何时使用外观模式:

1.在设计阶段初期，要有意识的将不同的两个层分离，比如经典的三层架构，就需要考虑在数据访问层和业务逻辑层、业务逻辑层和表示层的层与层之间建立外观Facade，这样可以为复杂的子系统提供一个简单的接口，使得耦合大大降低。

2.在开发阶段，子系统往往因为不断的重构演化而变得越来越复杂。增加外观Facade可以提供一个简单的接口，减少它们之间的依赖

3.在维护一个遗留的大型系统时，可能这个系统已经非常难以维护和扩展了，可以为新系统开发一个外观Facade类，来提供设计粗糙或高度复杂的遗留代码的比较清晰简单的接口，让新系统与Facade对象交互，Facade与遗留代码交互所有复杂的工作。