中介者模式（Mediator Pattern）
1. 定义
中介者模式是一种行为型设计模式，它通过引入一个中介者对象来简化对象之间的通信。中介者模式的主要目的是减少多个对象之间的直接交互，使得这些对象不需要显式地相互引用，从而降低系统的耦合度。
2. 核心概念
- 中介者（Mediator）：定义一个接口，用于与各个同事对象（Colleague）进行通信。
- 具体中介者（Concrete Mediator）：实现中介者接口，知道并维护其各个同事对象，并负责协调这些对象之间的交互。
- 同事类（Colleague）：每个同事类都知道其中介者对象，并且在需要与其他同事通信时，通过中介者进行。
3. 使用案例
- 聊天室：多个用户通过一个聊天室进行交流，聊天室作为中介者，处理用户之间的消息传递。
- 航空交通控制系统：飞机、塔台、地面控制等通过一个中介者（如控制中心）进行协调。
- GUI组件之间的交互：例如，按钮点击事件可能需要更新多个其他组件的状态，中介者可以管理这些组件之间的交互。
4. 优点与缺点
优点：
- 降低了系统的复杂度，减少了类之间的依赖关系。
- 提高了系统的灵活性和可扩展性。
- 简化了对象协议，使得同事类之间的交互更加清晰。
缺点：
- 中介者可能变得过于复杂，因为它集中了系统的控制逻辑。
- 如果中介者设计不当，可能会导致系统的性能瓶颈。
5. 实现示例
C++ 实现
#include <iostream>
#include <string>
#include <vector>
// 抽象同事类
class Colleague {
public:
virtual void sendMessage(std::string message) = 0;
virtual void receiveMessage(std::string message) = 0;
};
// 抽象中介者
class Mediator {
public:
virtual void send(std::string message, Colleague* colleague) = 0;
};
// 具体同事类
class ConcreteColleague : public Colleague {
private:
Mediator* mediator;
public:
ConcreteColleague(Mediator* m) : mediator(m) {}
void sendMessage(std::string message) override {
mediator->send(message, this);
}
void receiveMessage(std::string message) override {
std::cout << "Received: " << message << std::endl;
}
};
// 具体中介者
class ConcreteMediator : public Mediator {
private:
std::vector<Colleague*> colleagues;
public:
void addColleague(Colleague* colleague) {
colleagues.push_back(colleague);
}
void send(std::string message, Colleague* sender) override {
for (auto colleague : colleagues) {
if (colleague != sender) {
colleague->receiveMessage(message);
}
}
}
};
int main() {
ConcreteMediator* mediator = new ConcreteMediator();
ConcreteColleague* user1 = new ConcreteColleague(mediator);
ConcreteColleague* user2 = new ConcreteColleague(mediator);
mediator->addColleague(user1);
mediator->addColleague(user2);
user1->sendMessage("Hello, World!");
user2->sendMessage("Hi, User1!");
delete user1;
delete user2;
delete mediator;
return 0;
}
C# 实现
using System;
using System.Collections.Generic;
// 抽象同事类
public abstract class Colleague
{
public abstract void SendMessage(string message);
public abstract void ReceiveMessage(string message);
}
// 抽象中介者
public abstract class Mediator
{
public abstract void Send(string message, Colleague colleague);
}
// 具体同事类
public class ConcreteColleague : Colleague
{
private Mediator mediator;
public ConcreteColleague(Mediator m)
{
mediator = m;
}
public override void SendMessage(string message)
{
mediator.Send(message, this);
}
public override void ReceiveMessage(string message)
{
Console.WriteLine($"Received: {message}");
}
}
// 具体中介者
public class ConcreteMediator : Mediator
{
private List<Colleague> colleagues = new List<Colleague>();
public void AddColleague(Colleague colleague)
{
colleagues.Add(colleague);
}
public override void Send(string message, Colleague sender)
{
foreach (var colleague in colleagues)
{
if (colleague != sender)
{
colleague.ReceiveMessage(message);
}
}
}
}
class Program
{
static void Main(string[] args)
{
var mediator = new ConcreteMediator();
var user1 = new ConcreteColleague(mediator);
var user2 = new ConcreteColleague(mediator);
mediator.AddColleague(user1);
mediator.AddColleague(user2);
user1.SendMessage("Hello, World!");
user2.SendMessage("Hi, User1!");
}
}
6. 类图
7. 总结
中介者模式通过引入一个中介者对象来管理对象之间的复杂交互，降低了系统的耦合度，提高了系统的可维护性和扩展性。在实际应用中，选择合适的中介者实现方式非常重要，以避免中介者本身成为系统的瓶颈。
