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

ゝ一纸荒年。 2022-04-25 09:20 195阅读 0赞

### 文章目录 ###

*   *   *  情景分析
         *  中介者模式的定义
         *  中介者模式的应用
         *   *  中介者模式的优点
             *  中介者模式的缺点
             *  中介者模式的使用场景
         *  \*参考书籍\* :

### 情景分析 ###

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

### 中介者模式的定义 ###

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

中介者模式的通用类图 :  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05vbnBjMTIz_size_16_color_FFFFFF_t_70]

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

*  **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

运行结果 :  
![在这里插入图片描述][20190531003019166.png]

### 中介者模式的应用 ###

#### 中介者模式的优点 ####

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

#### 中介者模式的缺点 ####

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

#### 中介者模式的使用场景 ####

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

### *参考书籍* : ###

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05vbnBjMTIz_size_16_color_FFFFFF_t_70]: /images/20220125/6e62d9e3c2cc49948302d72bdf4d4dfe.png
[20190531003019166.png]: /images/20220125/5458d6c948b04f428ac19d045371b242.png