设计模式之中介者模式

1、一系列的对象交互。中介者使各对象不需要显示相互引用，从而使其耦合松散，而且可以独立地变化它们之间的交互。

UML图如下：

2、中介者模式很容易在系统中应用，也很容易在系统中误用。当系统出现了“多对多”交互复杂的对象群时，不要急于使用中介者模式，而要先反思你的系统在设计上是不是合理。

优点：

首先是Mediator的出现减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator，其次由于把对象如何协作进行了抽象，将中介作为一个独立的概念，并将其封装在一个对象中，这样关注的对象就从对象本身的行为转移到它们之间的交互上来，也就是站在一个更宏观的角度去看待系统。

缺点：

由于ConcreteMediator控制了集中化，于是就把复杂性变为了中介者的复杂性，这就使得中介者会比任何一个Colleague都复杂。

3、中介者模式一般应用于一组对象以定义良好但是复杂的方式进行通信的场合，以及想定制一个分布在多个类中的行为，而不想生成太多子类的场合。

4、C++代码实现：

[cpp] view plaincopy 

1. #include <iostream>  
2. #include <string>  
3. using namespace std;  
4. 
   
5. class Colleague;  
6. /*  Mediator类，抽象中介者类  */  
7. class Mediator   
8. {  
9. public:  
10.     virtual void Send(string name, Colleague * pColleague) = 0;  
11. }; 
12.  
13. /* Colleague类，抽象同事类  */  
14. class Colleague  
15. {  
16. protected:  
17.     Mediator * pMediator;  
18. public:  
19.     Colleague(Mediator * pMediator)   
20.     {  
21.         this->pMediator = pMediator;  
22.     }  
23. };  
24. class ConcreteColleague1 : public Colleague  
25. {  
26. public:  
27.     ConcreteColleague1(Mediator * pMediator) : Colleague(pMediator) {};  
28.       
29.     void Send(string message)   
30.     {  
31.         pMediator->Send(message, this);  
32.     }  
33.       
34.     void Notify(string message)   
35.     {  
36.         cout << "同事1得到消息：" << message << endl;  
37.     }  
38. };  
39. class ConcreteColleague2 : public Colleague  
40. {  
41. public:  
42.     ConcreteColleague2(Mediator * pMediator) : Colleague(pMediator) {};  
43.       
44.     void Send(string message)   
45.     {  
46.         pMediator->Send(message, this);  
47.     }  
48.       
49.     void Notify(string message)   
50.     {  
51.         cout << "同事2得到消息：" << message << endl;  
52.     }  
53. };  
54. 
    
55. /* ConcreteMediator类，具体中介者类  */  
56. class ConcreteMediator : public Mediator  
57. {  
58. private:  
59.     ConcreteColleague1 * pColleague1;  
60.     ConcreteColleague2 * pColleague2;  
61. public:  
62.     void setColleague1(ConcreteColleague1 * pColleague1)   
63.     {  
64.         this->pColleague1 = pColleague1;  
65.     }  
66.       
67.     void setColleague2(ConcreteColleague2 * pColleague2)  
68.     {  
69.         this->pColleague2 = pColleague2;  
70.     }  
71.       
72.     void Send(string message, Colleague * pColleague)   
73.     {  
74.         if (pColleague == pColleague1)   
75.         {  
76.             pColleague2->Notify(message);  
77.         }  
78.         else   
79.         {  
80.             pColleague1->Notify(message);  
81.         }  
82.     }  
83. }; 
84.  
85. int main()   
86. {  
87.     ConcreteMediator * pMediator = new ConcreteMediator();  
88.     /* 让两个具体同事类认识中介者对象  */  
89.     ConcreteColleague1 * pC1 = new ConcreteColleague1(pMediator);  
90.     ConcreteColleague2 * pC2 = new ConcreteColleague2(pMediator);  
91.     /* 让中介者认识各个具体同事类对象  */  
92.     pMediator->setColleague1(pC1);  
93.     pMediator->setColleague2(pC2);  
94.     /* 具体同事类对象的发送信息都是通过中介者转发 */  
95.     pC1->Send("吃过饭了没有");  
96.     pC2->Send("还没呢，你要请客？");  
97.     return 0;  
98. }