[C++实现 设计模式(8)] : 中介者模式

情景分析

       以租房为例子，如果没有房屋中介，那么房客要自己找房东，而房东也要自己找房客，非常不方便 . 有了房屋中介机构就方便了，房东可以把要出租的房屋信息放到中介机构，而房客可以去中介机构咨询 . 在软件中，就是多个对象之间需要通信，如果没有中介，对象就需要知道其他对象，最坏情况下，可能需要知道所有其他对象，而有了中介对象就方便多了，对象只需与中介对象通信，而不用知道其他的对象 .

中介者模式的定义

定义 : 用一个中介对象封装一系列的对象交互 , 中介者使各对象不需要显示地相互作用 , 从而使其耦合松散 , 而且可以独立地改变它们之间的交互 .

中介者模式的通用类图 :

从类图中看，中介者模式由以下几部分组成 :

• Mediator抽象中介者角色
  抽象中介者角色定义统一的接口，用于各同事角色之间的通信 .
• Concrete Mediator具体中介者角色
  具体中介者角色通过协调各同事角色实现协作行为， 因此它必须依赖于各个同事角色 .
• Colleague同事角色
  每一个同事角色都知道中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作 . 每个同事类的行为分为两种: 一种是同事本身的行为，比如改变对象本身的状态，处理自己的行为等，这种行为叫做自发行为(Self-Method)，与其他的同事类或中介者没有任何的依赖;第二种是必须依赖中介者才能完成的行为，叫做依赖方法(Dep-Method) .

代码如下 :

#include<iostream>
#include<string>
//#include<vld.h>

using namespace std;

//中介者模式
#if 0
class Mediator;
//抽象人 类
class Person
{
protected:
	//中介
	Mediator * _mediator; 
public:
	//设置中介
	virtual void SetMediator(Mediator *mediator) = 0;
	//向中介发送信息
	virtual void SendMessage(string message) = 0; 
	//从中介获取信息
	virtual void GetMessage(string message) = 0;    
};
//抽象中介机构
class Mediator
{
public:
	//中介者最重要的方法叫做事件方法 , 处理多个对象之间的关系
	virtual void Send(string message, Person *person) = 0;
	//设置租房者方事件
	virtual void Setrenter(Person *renter) = 0;
	//设置房东事件
	virtual void SethouseMediator(Person *houseMediator) = 0;
};

//租房者
class Renter: public Person
{
public:
	void SetMediator(Mediator *mediator) 
	{ _mediator = mediator ; }
	void SendMessage(string message)
	{ _mediator->Send(message, this) ; }
	void GetMessage(string message) 
	{ cout<<"租房者收到信息"<<message ; }
};
//房东
class Landlord: public Person
{
public:
	void SetMediator(Mediator *mediator) 
	{ _mediator = mediator ; }
	void SendMessage(string message) 
	{ _mediator->Send(message, this) ; }
	void GetMessage(string message) 
	{ cout<<"房东收到信息："<<message ; }
};
//房屋中介(具体中介者)
class HouseMediator : public Mediator
{
private:
	//租房者
	Person * _renter; 
	//房东
	Person * _houseMediator; 
public:
	HouseMediator()
		: _renter(nullptr) , _houseMediator(nullptr)
	{}
	void Setrenter(Person *renter) 
	{ _renter = renter ; }
	void SethouseMediator(Person *houseMediator)
	{ _houseMediator = houseMediator ; }
	void Send(string message, Person *person) 
	{
		//租房者给房东发信息
		if(person == _renter) 
		{
			//房东收到信息
			_houseMediator->GetMessage(message);
		}	 
		else
		{
			_renter->GetMessage(message);
		}	
	}
};



//测试案例
int main()
{	
	Mediator *mediator = new HouseMediator();
	//租房者
	Person *person1 = new Renter();    
	//房东
	Person *person2 = new Landlord();  
	mediator->Setrenter(person1);
	mediator->SethouseMediator(person2);
	person1->SetMediator(mediator);
	person2->SetMediator(mediator);
	person1->SendMessage("我想在中山路附近租套房子，价格1200元一个月\n");
	person2->SendMessage("出租房子：中山路100号，65平米，1000元一个月\n");
	
	delete person1; 
	delete person2;
	delete mediator;
	return 0;
}

#endif

运行结果 :

中介者模式的应用

中介者模式的优点

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

中介者模式的缺点

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

中介者模式的使用场景

       中介者模式简单，但是简单不代表容易使用，很容易被误用 . 在面向对象的编程中，对象和对象之间必然会有依赖关系，如果某个类和其他类没有任何相互依赖的关系，那这个类就是一个“孤岛”，在项目中就没有存在的必要了! 就像是某个人如果永远独立生活，与任何人都没有关系，那这个人基本上就算是野人了一排除在人类这个定义之外 .
       类之间的依赖关系是必然存在的，一个类依赖多个类的情况也是存在的，存在即合理，那是否可以说只要有多个依赖关系就考虑使用中介者模式呢?答案是否定的. 中介者模式未必能帮你把原本凌乱的逻辑整理得清清楚楚，而且中介者模式也是有缺点的，这个缺点在使用不当时会被放大，比如原本就简单的几个对象依赖关系，如果为了使用模式而加入了中介者，必然导致中介者的逻辑复杂化，因此中介者模式的使用需要“量力而行”!中介者模式适用于多个对象之间紧密耦合的情况，紧密耦合的标准是:在类图中出现了蜘蛛网状结构 . 在这种情况下一定要考虑使用中介者模式，这有利于把蜘蛛网梳理为星型结构，使原本复杂混乱的关系变得清晰简单.

参考书籍 :

                  <<设计模式之禅 第二版>>
                  <<设计模式>>