设计模式之中介者模式（C++）

中介者模式，用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地互相引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。该模式很好理解，其UML图如下：

Mediator中每个交互者的引用，在Mediator内部封装了各种类之间的交互。至于那个类和那个类交合则有具体的需求来决定。示例代码如下：

// MediatorModel.h文件
#pragma once
#include 
#include 

class Colleague;

class Mediator
{
public:
	virtual void send(std::string  msg, Colleague * p) = 0;
};

class Colleague
{
protected:
	Mediator * m_mediator;
public:
	Colleague(Mediator * p)
	{
		m_mediator = p;
	}
	virtual void send(std::string msg) = 0;
	virtual void notify(std::string msg) = 0;
};

class ConcreteColleague_0 : public Colleague
{
public:
	ConcreteColleague_0(Mediator * p) : Colleague(p) {}
	void send(std::string msg)
	{
		m_mediator->send(msg, this);
	}
	void notify(std::string msg)
	{
		std::cout << "Colleague_0 收到了消息：" << msg << std::endl;
	}
};

class ConcreteColleague_1 : public Colleague
{
public:
	ConcreteColleague_1(Mediator * p) : Colleague(p) {}
	void send(std::string msg)
	{
		m_mediator->send(msg, this);
	}
	void notify(std::string msg)
	{
		std::cout << "Colleague_1 收到了消息：" << msg << std::endl;
	}
};

class ConcreteMediator : public Mediator
{
private:
	// 这里也可以是一个列表
	Colleague * m_p1;
	Colleague * m_p2;
public:
	void addColleague(Colleague * p1, Colleague * p2)
	{
		m_p1 = p1;
		m_p2 = p2;
	}
	void send(std::string msg, Colleague * p)
	{
		// 这里接受来自一个同事发过来的消息，具体应该给谁要根据需求来
		// 这里知识一个很简单的应用。比如该类总可以是有两个队列。
		// 一个队列是客户，一个队列是客服
		if (p == m_p1)
			m_p2->notify(msg);
		else
			m_p1->notify(msg);	
	}
};

测试代码如下：

#include 
#include "MediatorModel.h"

int main()
{
	using namespace std;
	// 中介者模式
	ConcreteMediator * p = new ConcreteMediator();
	Colleague * pCol1 = new ConcreteColleague_0(p);
	Colleague * pCol2 = new ConcreteColleague_1(p);
	p->addColleague(pCol1, pCol2);
	pCol1->send("你下班了吗？");
	pCol2->send("没呢，你呢？");
	delete pCol1;
	delete pCol2;
	delete p;

	getchar();
	return 0;

测试结果如下图：

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