一、前言
平常我们写一个聊天软件，如果我们只是各个客户端之间连接聊天，那估计我们会写的想哭，那如果我们用服务器作为中间媒介，通过服务器来完成转发，群聊等客户端之间的连接，那样我们就可以最大程度的为各个客户端之间解耦，把它们之间的通信方法抽出来单独实现，
如图1就是不使用中介媒体的时候的结构图：
如图2就是使用我们所说的服务器作为中间媒介的情况的结构图：
二、中介模式
图二就是我们所说的中介模式！
在GOF的《设计模式:可复用面向对象软件的基础》一书中对中介者模式是这样说的：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
UML图如下所示：
Mediator：中介者，它定义了一个接口用于与各个Colleague对象通信；
ConcreteMediator：具体的中介者，它通过协调各Colleague对象实现协作行为；并了解和维护它的各个Colleague；（服务器）
Colleague：同事类，每一个同事类都知道它的中介者对象；每一个同时对象在需要与其他的同事通信的时候，而是与它的中介者通信。（客户端）
它们之间是按照以下方式进行协作的：
同事向一个中介者对象发送和接收请求。中介者在各同事间适当地转发请求以实现协作行为。
#include <iostream>
using namespace std;
#define DELETE(p) if (p) { delete p; p = NULL; } //回收内存
class Colleague;
//中介者
class Mediator
{
public:
virtual void Send(char *message, Colleague *pColleague) = 0;
};
//同事类
class Colleague
{
public:
Colleague(Mediator* mediator):m_pMediator(mediator){};
virtual void send(char* message)=0;
virtual void notify(char* message)=0;
protected:
Mediator* m_pMediator;
};
//具体的同事类1
class ConcreteColleague1:public Colleague
{
public:
ConcreteColleague1(Mediator* mediator):Colleague(mediator){};
void send(char* message)
{
m_pMediator->Send(message,this);
}
void notify(char* message)
{
cout<<"ConcreteColleague1 is handling the message("<<message<<")"<<endl;
}
};
//具体的同事类2
class ConcreteColleague2:public Colleague
{
public:
ConcreteColleague2(Mediator* mediator):Colleague(mediator){};
void send(char* message)
{
m_pMediator->Send(message,this);
}
void notify(char* message)
{
cout<<"ConcreteColleague2 is handling the message("<<message<<")"<<endl;
}
};
//具体的中介者
class ConcreteMediator:public Mediator
{
public:
void Send(char* message,Colleague* colleague)
{
ConcreteColleague1 *pConcreteColleague1 = dynamic_cast<ConcreteColleague1 *>(colleague);
if (pConcreteColleague1)
{
cout<<"message from ConcreteColleague1 to ConcreteColleague2"<<endl;
if (m_pColleague2)
{
m_pColleague2->notify(message);
}
}
else
{
cout<<"message from ConcreteColleague2 to ConcreteColleague1"<<endl;
if (m_pColleague1)
{
m_pColleague1->notify(message);
}
}
}
void SetColleague1(Colleague *pColleague)
{
m_pColleague1 = dynamic_cast<ConcreteColleague1 *>(pColleague);
}
void SetColleague2(Colleague *pColleague)
{
m_pColleague2 = dynamic_cast<ConcreteColleague2 *>(pColleague);
}
private:
Colleague* m_pColleague1;
Colleague* m_pColleague2;
};
int main()
{
// Create the mediator
Mediator *pMediator = new ConcreteMediator();
// Create the Colleague
Colleague *pColleague1 = new ConcreteColleague1(pMediator);
Colleague *pColleague2 = new ConcreteColleague2(pMediator);
//set the ConcreteColleague to the concreteMediator
ConcreteMediator *pConcreteMediator = dynamic_cast<ConcreteMediator *>(pMediator);
pConcreteMediator->SetColleague1(pColleague1);
pConcreteMediator->SetColleague2(pColleague2);
char message[260] = "hello guys?";
pColleague1->send(message);
pColleague2->send(message);
DELETE(pMediator);
DELETE(pColleague1);
DELETE(pColleague2);
pConcreteMediator=NULL;
//delete(pMediator);
return 0;
}三、使用中介者模式的场合和优缺点
使用终结者模式的场合
1.一组定义良好的对象，现在要进行复杂的通信。
2.定制一个分布在多个类中的行为，而又不想生成太多的子类。
使用中介者模式的优点：
1.降低了系统对象之间的耦合性，使得对象易于独立的被复用。
2.提高系统的灵活性，使得系统易于扩展和维护。
使用中介者模式的缺点：
“中介“承担了较多的责任，所以一旦这个中介对象出现了问题，那么整个系统就会受到重大的影响。
原文地址：http://blog.csdn.net/liucimin/article/details/40831951
