23种设计模式-中介者(Mediator)设计模式

一.什么是中介者设计模式？

 中介者设计模式是一种行为型模式，主要用来降低对象之间的耦合性。它通过一个中介者对象，封装对象之间的交互，使得多个对象之间不需要直接引用，便于系统的扩展和维护。
 中介者模式将对象之间的复杂网状依赖关系转换为星形依赖关系（所有对象依赖中介者），从而简化系统。

二.中介者模式的特点

• 降低耦合性：将类与类之间的直接关系移交给中介者管理。
• 增强可维护性：通过中介者控制对象的交互逻辑，便于修改和扩展。

三.中介者模式的结构

• Mediator（抽象中介者）：定义与同事对象通信的接口。
• ConcreteMediator（具体中介者）：实现抽象中介者接口，协调同事对象之间的交互。
• Colleague（同事类）：依赖中介者，与其他同事类交互的逻辑通过中介者完成。

四.中介者模式的优缺点

• 优点:
  • 降低耦合性：对象不需要了解其他对象的实现。
  • 集中化控制：所有交互逻辑集中到中介者中。
• 缺点:
  • 复杂性提升：中介者可能变得臃肿，难以维护。

五.中介者模式的 C++ 实现

 以下代码展示了一个简单的聊天室系统，其中聊天室（ChatMediator）作为中介者，协调用户之间的消息发送。

#include <iostream>
#include <string>
#include <vector>
#include <memory>
using namespace std;

// 抽象中介者类
class Mediator {
public:
    virtual void SendMessage(const string& message, const string& sender) = 0;
    virtual void AddUser(shared_ptr<class Colleague> user) = 0;
    virtual ~Mediator() = default;
};

// 同事类基类
class Colleague {
protected:
    string name;
    shared_ptr<Mediator> mediator; // 依赖中介者
public:
    Colleague(const string& userName, shared_ptr<Mediator> med)
        : name(userName), mediator(med) {}

    virtual void ReceiveMessage(const string& message, const string& sender) = 0;
    string GetName() const { return name; }
    virtual ~Colleague() = default;
};

// 具体中介者类：聊天室
class ChatMediator : public Mediator {
private:
    vector<shared_ptr<Colleague>> users; // 用户列表
public:
    void AddUser(shared_ptr<Colleague> user) override {
        users.push_back(user);
    }

    void SendMessage(const string& message, const string& sender) override {
        for (const auto& user : users) {
            if (user->GetName() != sender) { // 排除发送者
                user->ReceiveMessage(message, sender);
            }
        }
    }
};

// 具体同事类：用户
class User : public Colleague {
public:
    User(const string& userName, shared_ptr<Mediator> med)
        : Colleague(userName, med) {}

    void SendMessage(const string& message) {
        cout << name << " 发送消息: " << message << endl;
        mediator->SendMessage(message, name); // 调用中介者发送消息
    }

    void ReceiveMessage(const string& message, const string& sender) override {
        cout << name << " 收到来自 " << sender << " 的消息: " << message << endl;
    }
};

// 主函数
int main() {
    // 创建中介者
    shared_ptr<Mediator> chatRoom = make_shared<ChatMediator>();

    // 创建用户
    shared_ptr<Colleague> user1 = make_shared<User>("Alice", chatRoom);
    shared_ptr<Colleague> user2 = make_shared<User>("Bob", chatRoom);
    shared_ptr<Colleague> user3 = make_shared<User>("Charlie", chatRoom);

    // 将用户添加到聊天室
    chatRoom->AddUser(user1);
    chatRoom->AddUser(user2);
    chatRoom->AddUser(user3);

    // 用户发送消息
    user1->SendMessage("Hello, everyone!");
    user2->SendMessage("Hi Alice!");
    user3->SendMessage("Good morning!");

    return 0;
}

六.中介者模式的 JAVA 实现

import java.util.ArrayList;
import java.util.List;

// 抽象中介者类
interface Mediator {
    void sendMessage(String message, String sender);
    void addUser(Colleague user);
}

// 同事类基类
abstract class Colleague {
    protected String name;
    protected Mediator mediator;

    public Colleague(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }

    public abstract void receiveMessage(String message, String sender);

    public String getName() {
        return name;
    }
}

// 具体中介者类：聊天室
class ChatMediator implements Mediator {
    private List<Colleague> users = new ArrayList<>();

    @Override
    public void sendMessage(String message, String sender) {
        for (Colleague user : users) {
            if (!user.getName().equals(sender)) { // 排除发送者
                user.receiveMessage(message, sender);
            }
        }
    }

    @Override
    public void addUser(Colleague user) {
        users.add(user);
    }
}

// 具体同事类：用户
class User extends Colleague {
    public User(String name, Mediator mediator) {
        super(name, mediator);
    }

    public void sendMessage(String message) {
        System.out.println(name + " 发送消息: " + message);
        mediator.sendMessage(message, name); // 调用中介者发送消息
    }

    @Override
    public void receiveMessage(String message, String sender) {
        System.out.println(name + " 收到来自 " + sender + " 的消息: " + message);
    }
}

// 主函数
public class MediatorPattern {
    public static void main(String[] args) {
        // 创建中介者
        Mediator chatRoom = new ChatMediator();

        // 创建用户
        Colleague user1 = new User("Alice", chatRoom);
        Colleague user2 = new User("Bob", chatRoom);
        Colleague user3 = new User("Charlie", chatRoom);

        // 将用户添加到聊天室
        chatRoom.addUser(user1);
        chatRoom.addUser(user2);
        chatRoom.addUser(user3);

        // 用户发送消息
        user1.sendMessage("Hello, everyone!");
        user2.sendMessage("Hi Alice!");
        user3.sendMessage("Good morning!");
    }
}

七.代码解析

• 中介者类：
  • ChatMediator 是具体的中介者，保存了所有用户的列表并负责消息的广播。
  • AddUser 方法用于将用户加入聊天室。
  • SendMessage 方法遍历所有用户，并调用每个用户的 ReceiveMessage 方法（排除消息发送者）。
• 同事类：
  • User 继承了 Colleague。它依赖中介者来完成消息发送，同时提供 ReceiveMessage 方法处理消息。
  • SendMessage 方法调用中介者的 SendMessage，通过中介者实现与其他用户的通信。
• 客户端：
  • 创建了中介者 chatRoom 并注册用户 user1、user2 和 user3。
  • 用户之间的通信由中介者负责，直接解耦了用户与用户之间的依赖关系。

八.总结

 中介者模式通过将对象间的通信逻辑抽离到中介者中，极大地降低了对象间的耦合性。虽然中介者可能会变得复杂，但对于需要频繁交互的系统，它是一种非常实用的设计模式。
应用场景:

• 聊天系统：中介者充当服务器，负责转发消息给所有用户。
• 航线控制系统：控制塔作为中介者，管理飞机之间的通信。
• GUI 组件交互：如按钮、输入框等组件通过中介者进行交互。