喜欢内容的话欢迎关注、点赞、收藏！感谢支持，祝大家祉猷并茂，顺遂无虞！

中介者模式（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. 总结

中介者模式通过引入一个中介者对象来管理对象之间的复杂交互，降低了系统的耦合度，提高了系统的可维护性和扩展性。在实际应用中，选择合适的中介者实现方式非常重要，以避免中介者本身成为系统的瓶颈。

欢迎关注、点赞、收藏！更多系列内容可以点击专栏目录订阅，感谢支持，再次祝大家祉猷并茂，顺遂无虞！

若将文章用作它处，请一定注明出处，商用请私信联系我！