Mediator(中介者)设计模式

声明：本博文篇幅短，适合review。

一、概念

       用一个中介者对象来封装一系列的对象交互。中介者使得各对象不需要显式地相互引用，从而使其松散耦合，而且可以独立地改变它们之间的交互。

二、模式结构图

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

class ConcreteMediator : public Mediator
{
public:
	void send(string msg, Colleague * clg){
		if (clg == mClgA){
			mClgB->receive(msg);
		}else if (clg == mClgB){
			mClgA->receive(msg);
		}
	}
	void introColleague(Colleague * clgA, Colleague * clgB){
		mClgA = clgA;
		mClgB = clgB;
	}
private:
	Colleague * mClgA;
	Colleague * mClgB;
};

class Colleague
{
public:
	Colleague(Mediator * mdt){
		mMdt = mdt;
	}
private:
	Mediator * mMdt;	
};

class ConcreteColleagueA : public Colleague
{
public:
	ConcreteColleagueA(Mediator * mdt) : mMdt(mdt) {}
	void notify(string msg){
		mMdt->send(msg, this);
	}
	void receive(string msg){
		cout<<“get msg from B  :”<<msg<<endl;
	}
}; 

class ConcreteColleagueB : public Colleague
{
public:
	ConcreteColleagueB(Mediator * mdt) : mMdt(mdt) {}
	void notify(string msg){
		mMdt->send(msg, this);
	}
	void receive(string msg){
		cout<<“get msg from A  :”<<msg<<endl;
	}
}; 

void main(){
	Mediator * mdt = new ConcreteMediator();
	Colleague * cA = new ConcreteColleagueA(mdt);
	Colleague * cB = new ConcreteColleagueB(mdt);
	
	mdt-> introColleague(cA, cB);
	cA->notify(“xxxx”);
	cB->notify(“yyyy”);
}

三、例子

class ChatSoft
{
public:
	virtual void send(string msg, Friend * frd) = 0;
};

class QQ : public ChatSoft
{
public:
	void send(string msg, Friend * frd){
		if (frd == mZs){
			mLs->receive(msg);
		}else if (frd == mLs){
			mZs->receive(msg);
		}
	}
	void introFriends(Friend * zs, Friend * ls){
		mZs = zs;
		mLs = ls;
	}
private:
	Friend * mZs;
	Friend * mLs;
};

class Friend
{
public:
	Friend(ChatSoft * cs){
		mCs = cs;
	}
private:
	ChatSoft * mCs;	
};

class ZhangSan : public Friend
{
public:
	ZhangSan(ChatSoft * cs) : mCs(cs) {}
	void notify(string msg){
		mCs->send(msg, this);
	}
	void receive(string msg){
		cout<<“get msg from LiSi  :”<<msg<<endl;
	}
}; 

class LiSi : public Friend
{
public:
	LiSi(ChatSoft * cs) : mCs(cs) {}
	void notify(string msg){
		mCs->send(msg, this);
	}
	void receive(string msg){
		cout<<“get msg from ZhangSan  :”<<msg<<endl;
	}
}; 

void main(){
	ChatSoft * qq = new QQ();
	Friend * zs = new ZhangSan(qq);
	Friend * ls = new LiSi(qq);
	
	qq-> introFriends(zs, ls);
	zs->notify(“hello ~”);
	ls->notify(“hi ~”);
}

四、优缺点

       1、优点

            a、适当地使用中介者模式可以避免同事类之间的过度耦合，使得各同事类之间可以相对独立地使用。

            b、提高系统的灵活性，使得系统易于扩展和维护。

       2、缺点

            a、把交互复杂性变为中介者复杂性。

            b、中介者若出问题，则对整个系统都产生影响。