设计模式之中介者模式

中介者模式（Mediator Pattern）是一种行为设计模式，用于减少对象之间的直接依赖关系，通过一个中介者对象来封装对象之间的交互。中介者模式将多个对象之间的复杂通信封装在一个中介者对象中，使得各个对象之间不需要直接引用彼此，从而实现松耦合。

组成部分

1. Mediator（中介者接口）：定义了一个接口用于与各同事（Colleague）对象通信。
2. ConcreteMediator（具体中介者）：实现中介者接口，协调各同事对象之间的交互。
3. Colleague（同事类）：各同事类只知道中介者对象，而不知道其他同事对象，所有通信通过中介者对象进行。

UML类图

+-------------------+          +------------------+
|   Mediator        |<>--------|   Colleague      |
+-------------------+          +------------------+
| +notify()         |          | +receive()       |
| +send()           |          | +send()          |
+-------------------+          +------------------+
          /|\                           /|\
           |                             |
           |                             |
           |                             |
+-------------------+         +-------------------+
|ConcreteMediator   |         | ConcreteColleague1|
+-------------------+         +-------------------+
| -colleague1       |         | -mediator         |
| -colleague2       |         +-------------------+
| +notify()         |                 |
| +send()           |                 |
+-------------------+                 |
           |                          |
           |                          |
           |                +-------------------+
           |                | ConcreteColleague2|
           |                +-------------------+
           |                | -mediator         |
           |                +-------------------+
           |                          |
           |                          |
           |                          |
           |                +-------------------+
           |                | ConcreteColleague3|
           |                +-------------------+
           |                | -mediator         |
           |                +-------------------+
           |                          |
           |                          |
           |                          |
           +--------------------------+

C++示例代码

以下是一个使用中介者模式的C++示例，展示了如何定义和使用中介者模式：

#include <iostream>
#include <string>
#include <vector>
#include <memory>

// 前向声明
class Colleague;
class ConcreteColleague1;
class ConcreteColleague2;
class ConcreteColleague3;

// 中介者接口
class Mediator {
public:
	virtual void notify(Colleague* sender, const std::string& event) const = 0;
	virtual ~Mediator() = default;
};

// 同事类
class Colleague {
protected:
	Mediator* mediator;

public:
	Colleague(Mediator* mediator) : mediator(mediator) {}
	virtual void send(const std::string& event) = 0;
	virtual void receive(const std::string& event) = 0;
	virtual ~Colleague() = default;
};

// 具体中介者类
class ConcreteMediator : public Mediator {
private:
	Colleague* colleague1;
	Colleague* colleague2;
	Colleague* colleague3;

public:
	void setColleague1(Colleague* c) {
		colleague1 = c;
	}

	void setColleague2(Colleague* c) {
		colleague2 = c;
	}

	void setColleague3(Colleague* c) {
		colleague3 = c;
	}

	void notify(Colleague* sender, const std::string& event) const override {
		if (sender == colleague1) {
			colleague2->receive(event);
			colleague3->receive(event);
		}
		else if (sender == colleague2) {
			colleague1->receive(event);
			colleague3->receive(event);
		}
		else if (sender == colleague3) {
			colleague1->receive(event);
			colleague2->receive(event);
		}
	}
};

// 具体同事类1
class ConcreteColleague1 : public Colleague {
public:
	ConcreteColleague1(Mediator* mediator) : Colleague(mediator) {}

	void send(const std::string& event) override {
		std::cout << "Colleague1 sends: " << event << std::endl;
		mediator->notify(this, event);
	}

	void receive(const std::string& event) override {
		std::cout << "Colleague1 receives: " << event << std::endl;
	}
};

// 具体同事类2
class ConcreteColleague2 : public Colleague {
public:
	ConcreteColleague2(Mediator* mediator) : Colleague(mediator) {}

	void send(const std::string& event) override {
		std::cout << "Colleague2 sends: " << event << std::endl;
		mediator->notify(this, event);
	}

	void receive(const std::string& event) override {
		std::cout << "Colleague2 receives: " << event << std::endl;
	}
};

// 具体同事类3
class ConcreteColleague3 : public Colleague {
public:
	ConcreteColleague3(Mediator* mediator) : Colleague(mediator) {}

	void send(const std::string& event) override {
		std::cout << "Colleague3 sends: " << event << std::endl;
		mediator->notify(this, event);
	}

	void receive(const std::string& event) override {
		std::cout << "Colleague3 receives: " << event << std::endl;
	}
};

int main() {
	ConcreteMediator*mediator = new ConcreteMediator();;

	Colleague * colleague1 = new ConcreteColleague1(mediator);
	Colleague * colleague2 = new ConcreteColleague2(mediator);
	Colleague * colleague3 = new ConcreteColleague3(mediator);

	mediator->setColleague1(colleague1);
	mediator->setColleague2(colleague2);
	mediator->setColleague3(colleague3);

	colleague1->send("Hello from Colleague1!");
	colleague2->send("Hello from Colleague2!");
	colleague3->send("Hello from Colleague3!");

	return 0;
}

代码解释

1. Mediator：定义了一个纯虚函数 notify，表示中介者接口，用于通知同事对象。
2. ConcreteMediator：实现了 Mediator 接口，管理并协调各同事对象之间的通信。
3. Colleague：定义了发送 send 和接收 receive 方法，同事对象通过中介者进行通信。
4. ConcreteColleague1、ConcreteColleague2 和 ConcreteColleague3：分别实现了 Colleague 接口，在 send 方法中通过中介者通知其他同事对象，在 receive 方法中处理接收到的事件。

优点

• 降低耦合：中介者模式通过引入中介者对象，减少了对象之间的直接依赖，使得系统更易于维护和扩展。
• 集中控制：中介者集中控制对象之间的交互，简化了对象之间的通信逻辑。

缺点

• 复杂性增加：中介者对象本身可能变得复杂，因为它需要处理所有对象之间的交互逻辑。
• 性能问题：如果中介者处理的对象数量很多，可能会导致性能瓶颈。

通过使用中介者模式，可以有效地管理对象之间的交互，减少系统的耦合度，提高系统的可维护性和可扩展性。