C++设计模式（12）：中介者模式

一、背景

在一个系统或者模块中，存在许多对象之间的相互引用，形成了复杂的网状交互关系图，显然这样看去，各个对象之间存在强耦合关系，对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。为了减少对象两两之间复杂的引用关系，使之成为一个松耦合的系统，我们需要使用中介者模式。

二、模式定义

中介者模式(Mediator Pattern)：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。它是一种对象行为型模式。中介者模式可以使得对象之间的关系数量急剧减少。

中介者模式，定义了一个中介对象来封装一系列对象之间的交互关系。中介者使各个对象之间不需要显式地相互引用，从而使耦合性降低，而且可以独立地改变它们之间的交互行为。

模式解析
在现实生活中，有很多中介者模式的身影，例如QQ游戏平台，聊天室、QQ群、短信平台和房产中介。不论是QQ游戏还是QQ群，它们都是充当一个中间平台，QQ用户可以登录这个中间平台与其他QQ用户进行交流，如果没有这些中间平台，我们如果想与朋友进行聊天的话，可能就需要当面才可以了。电话、短信也同样是一个中间平台，有了这个中间平台，每个用户都不要直接依赖与其他用户，只需要依赖这个中间平台就可以了，一切操作都由中间平台去分发。

三、模式角色和UML类图

抽象中介者（Mediator）:中介者定义一个接口用于与各同事（Colleague）对象通信。

具体中介者（ConcreteMediator）: 具体中介者通过协调各同事对象实现协作行为。了解并维护它的各个同事。

抽象同事类（Colleague）: 定义同事类接口,定义各同事的公有方法。

具体同事类（ConcreteColleague）:实现抽象同事类中的方法。每一个同事类需要知道中介者对象；每个具体同事类只需要 了解自己的行为，而不需要了解其他同事类的情况。每一个同事对象在需与其他的同事通信的时候，与它的中介者通信。

代码示例

#include<iostream>
#include<string>
#include<map>
using namespace std;
class Mediator;
/* 抽象同事类 */
class Colleague {
public:
	virtual void rcvMsg(string msg) = 0;
	virtual void sndMsg(int toWho, string str) = 0;
	void setMediator(Mediator*	pMediator) {
		this->pMediator = pMediator;
	}
protected:
	Mediator *pMediator;
};
/* 抽象中介者类 */
class Mediator {
public:
	virtual void operation(int nWho, string str) = 0;
	virtual void registerUser(int nWho, Colleague *aColleague) = 0;
};
/* 具体中介者 */
class ConcreteMediator:public Mediator{
public:
	void operation(int nWho, string str) {
		map<int, Colleague*>::const_iterator itr = m_mpColleague.find(nWho);
		if (itr == m_mpColleague.end()){
			cout << "not found this colleague!" << endl;
			return;
		}
		Colleague* pc = itr->second;
		pc->rcvMsg(str);
	}

	void registerUser(int nWho, Colleague *aColleague) {
		map<int, Colleague*>::const_iterator itr = m_mpColleague.find(nWho);
		if (itr == m_mpColleague.end()){
			m_mpColleague.insert(make_pair(nWho, aColleague));
			aColleague->setMediator(this);//同时将中介类暴露给colleague 
		}
	}
private:
	map<int, Colleague*> m_mpColleague;
};
class ConcreteColleagueA:public Colleague {
public:
	void sndMsg(int toWho, string str) {
		cout << "send msg from colleagueA,to:" << toWho << endl;
		pMediator->operation(toWho, str);
	}
	void rcvMsg(string str) {
		cout << "ConcreteColleagueA reveivemsg:" << str << endl;
	}
};
class ConcreteColleagueB :public Colleague {
public:
	void sndMsg(int toWho, string str) {
		cout << "send msg from colleagueB,to:" << toWho << endl;
		pMediator->operation(toWho, str);
	}
	void rcvMsg(string str) {
		cout << "ConcreteColleagueB reveivemsg:" << str << endl;
	}
};
int main() {
	Colleague * pa = new ConcreteColleagueA();
	Colleague * pb = new ConcreteColleagueB();
	Mediator * pm = new ConcreteMediator();
	
	/* 将自己注册给中介者 */
	pm->registerUser(1, pa);
	pm->registerUser(2, pb);

	/* sendmsg from a to b */
	pa->sndMsg(2, "hello,i am a");
	/* sendmsg from b to a */
	pb->sndMsg(1, "hello,i am b");
	return 0;
}

四、模式总结

适用性

1. 系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。
2. 一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。
3. 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。可以通过引入中介者类来实现，在中介者中定义对象。

优点

1. 减少类间的依赖，把原有的一对多的依赖变成了一对一的依赖，同事类只依赖中介者，减少了依赖，当然同时也降低了类间的耦合

缺点

1. 中介者模式的缺点就是中介者会膨胀得很大，而且逻辑复杂，原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。