一、前言

平常我们写一个聊天软件，如果我们只是各个客户端之间连接聊天，那估计我们会写的想哭，那如果我们用服务器作为中间媒介，通过服务器来完成转发，群聊等客户端之间的连接，那样我们就可以最大程度的为各个客户端之间解耦，把它们之间的通信方法抽出来单独实现，

如图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.提高系统的灵活性，使得系统易于扩展和维护。

使用中介者模式的缺点：

“中介“承担了较多的责任，所以一旦这个中介对象出现了问题，那么整个系统就会受到重大的影响。

设计模式之: 中介者模式