重温设计模式--中介者模式

1. 中介者模式介绍

   • 定义：中介者模式是一种行为设计模式，它通过引入一个中介者对象来封装一系列对象之间的交互。中介者使得各个对象之间不需要显式地相互引用，从而降低了它们之间的耦合度，并且可以更方便地对它们的交互进行管理和协调。
   • 工作原理：系统中的多个对象（同事对象）之间存在复杂的相互引用和交互关系，这些关系使得系统变得复杂且难以维护。中介者模式将这些交互逻辑集中到一个中介者对象中，同事对象只需要和中介者对象进行通信，而不用直接与其他同事对象交互。当一个同事对象的状态发生变化或者需要执行某些操作时，它通过中介者对象来通知其他相关的同事对象。
   • 类比：可以将中介者模式类比为机场的塔台（中介者）和飞机（同事对象）之间的关系。飞机之间不需要直接通信来协调起降等操作，而是通过塔台来传递信息和指令。塔台知道每架飞机的状态和需求，并且根据这些信息来协调飞机的行动，确保飞行安全和秩序。

2. 角色构成及职责

   • 中介者（Mediator）接口或抽象类：定义了同事对象与中介者进行通信的接口方法。通常包括用于通知中介者对象状态变化的方法，以及中介者用来通知同事对象执行操作的方法。
   • 具体中介者（Concrete Mediator）类：实现了中介者接口，它包含了对各个同事对象的引用，并且实现了协调同事对象之间交互的具体逻辑。例如，在一个聊天软件的中介者实现中，具体中介者需要知道每个聊天用户（同事对象）的信息，并且根据用户发送的消息来转发给其他相关用户。
   • 同事（Colleague）接口或抽象类：定义了同事对象的基本接口，包括与中介者通信的方法。同事对象通过这些方法来向中介者发送自己的状态变化信息或者接收中介者传来的通知。
   • 具体同事（Concrete Colleague）类 ：实现了同事接口，每个具体同事对象代表系统中的一个实体，它们有自己的状态和行为。当自己的状态发生变化时，通过中介者接口方法通知中介者；同时，也会接收中介者传来的通知并执行相应的操作。
     

3. 优点

   • 降低耦合度：同事对象之间的直接依赖关系被转移到中介者对象上，使得同事对象之间的耦合度大大降低。这样，当一个同事对象发生变化时，对其他同事对象的影响主要通过中介者来控制，减少了系统中复杂的连锁反应。
   • 易于维护和扩展：由于交互逻辑集中在中介者对象中，所以当需要修改或扩展系统的交互方式时，只需要修改中介者对象的代码，而不需要在多个同事对象中进行分散的修改。同时，添加新的同事对象也相对简单，只需要在中介者对象中添加对新同事对象的引用和相应的交互逻辑即可。
   • 提高代码的复用性：中介者对象的交互逻辑可以在不同的系统中复用。例如，一个通用的消息转发中介者可以应用于多种不同的消息传递场景，只要同事对象遵循相同的接口与中介者进行通信。

4. 缺点

   • 中介者可能变得复杂：如果系统中的同事对象较多，交互逻辑复杂，那么中介者对象可能会变得非常庞大和复杂，包含大量的协调代码，导致中介者本身的维护难度增加。
   • 系统的分布式处理能力受限：中介者模式将交互集中在一个中介者对象上，对于一些需要分布式处理或者高度并行处理的系统，可能不太适合，因为所有的交互都需要经过中介者，可能会成为性能瓶颈。

5. 应用场景

   • 图形用户界面（GUI）开发：在GUI系统中，多个控件（如按钮、文本框、下拉菜单等）之间可能存在复杂的交互关系。例如，当用户在一个文本框中输入内容后，可能需要更新其他相关控件的显示状态。通过中介者模式，可以将这些控件之间的交互逻辑封装在一个中介者对象中，使得控件之间的耦合度降低，便于维护和扩展。
   • 游戏开发：在游戏中，不同的游戏角色、道具、场景元素之间可能需要进行各种交互。例如，当一个角色捡起一个道具时，可能会触发其他角色的反应或者场景的变化。使用中介者模式可以有效地管理这些交互，使游戏的逻辑更加清晰。
   • 分布式系统中的消息传递：在分布式系统中，多个节点之间需要传递消息和协调工作。虽然中介者模式在分布式处理方面有一定的局限性，但在一些相对简单的分布式消息传递场景中，通过一个中介者节点来转发和协调消息，可以降低节点之间的直接通信复杂度。

6. C++代码示例

   • 中介者接口
     *

     class Mediator {
     public:
         virtual void notify(const std::string& sender, const std::string& event) = 0;
     };

   • 同事接口
     *

     class Colleague {
     protected:
         Mediator* mediator;
     public:
         Colleague(Mediator* m) : mediator(m) {}
         virtual void send(const std::string& event) = 0;
         virtual void receive(const std::string& sender, const std::string& event) = 0;
     };

   • 具体同事类A
     *

     class ConcreteColleagueA : public Colleague {
     public:
         ConcreteColleagueA(Mediator* m) : Colleague(m) {}
         void send(const std::string& event) override {
             mediator->notify("ConcreteColleagueA", event);
         }
         void receive(const std::string& sender, const std::string& event) override {
             if (sender == "ConcreteColleagueB") {
                 std::cout << "ConcreteColleagueA received event '" << event << "' from ConcreteColleagueB" << std::endl;
             }
         }
     };

   • 具体同事类B
     *

     class ConcreteColleagueB : public Colleague {
     public:
         ConcreteColleagueB(Mediator* m) : Colleague(m) {}
         void send(const std::string& event) override {
             mediator->notify("ConcreteColleagueB", event);
         }
         void receive(const std::string& sender, const std::string& event) override {
             if (sender == "ConcreteColleagueA") {
                 std::cout << "ConcreteColleagueB received event '" << event << "' from ConcreteColleagueA" << std::endl;
             }
         }
     };

   • 具体中介者类
     *

     class ConcreteMediator : public Mediator {
     private:
         ConcreteColleagueA* colleagueA;
         ConcreteColleagueB* colleagueB;
     public:
         void setColleagueA(ConcreteColleagueA* a) { colleagueA = a; }
         void setColleagueB(ConcreteColleagueB* b) { colleagueB = b; }
         void notify(const std::string& sender, const std::string& event) override {
             if (sender == "ConcreteColleagueA") {
                 colleagueB->receive(sender, event);
             } else if (sender == "ConcreteColleagueB") {
                 colleagueA->receive(sender, event);
             }
         }
     };

   • 使用示例
     *

     int main() {
         ConcreteMediator mediator;
         ConcreteColleagueA colleagueA(&mediator);
         ConcreteColleagueB colleagueB(&mediator);
         mediator.setColleagueA(&colleagueA);
         mediator.setColleagueB(&colleagueB);
         colleagueA.send("Hello from A");
         colleagueB.send("Hi from B");
         return 0;
     }

   • 在这个代码示例中，Mediator 是中介者接口，定义了 notify 方法用于接收同事对象的通知。Colleague 是同事接口，包含了发送消息和接收消息的方法。ConcreteColleagueA 和 ConcreteColleagueB 是具体同事类，它们通过中介者来发送和接收消息。ConcreteMediator 是具体中介者类，它包含了对两个具体同事对象的引用，并在 notify 方法中实现了根据发送者来通知相应同事对象接收消息的逻辑。在 main 函数中，创建了中介者、同事对象，并将同事对象与中介者关联起来，然后通过同事对象发送消息来演示中介者模式的消息传递过程。

C++代码示例2

#include<iostream>
#include<string>
using namespace std;
class Country;
//抽象类  联合国
class UN
{
public:
	virtual void delcare(string message , Country *m_country){}
	virtual void initcountry(Country*s1,Country*s2){};
};
//国家
class Country
{
protected:
	UN *m_un;
public:
	Country(UN* name):m_un(name){}
	virtual void delcare(string m_message){}

};
//美国
class USA:public Country
{
public:
	USA(UN* name):Country(name){}
	void delcare(string message)
	{
		cout<<"美国: "<<message<<endl;
	}
};
//伊拉克
class Iraq:public Country
{
public:
	Iraq(UN* name):Country(name){}
	void delcare(string message)
	{
		cout<<"伊拉克："<<message<<endl;
	}
};

//安理会
class Security:public UN
{
private:
	Country *m_usa;
	Country *m_iraq;

public:
	
	void initcountry(Country*s1 , Country*s2)
	{
		m_usa = s1;
		m_iraq = s2;
	}
	

	void delcare(string message , Country *m_country)
	{
		if(m_country==m_usa)
		{
			m_usa->delcare(message);
		}
		else
		{
			m_iraq->delcare(message);
		}
	}
};


int main()
{
	UN *m_sec = new Security();//创建安理会
	Country*country_usa = new USA(m_sec);//创建美国
	Country*country_iraq = new Iraq(m_sec);//创建伊拉克，美国和伊拉克有共同的中介者：安理会，m_sec
	m_sec->initcountry(country_usa,country_iraq);


	m_sec->delcare("我要干死你" , country_usa);
	m_sec->delcare("来呀，cnm，互相伤害呀" , country_iraq);


	cout<<endl<<endl;
	return 0;
}