C++ 设计模式之中介者模式

【声明】本题目来源于卡码网（题目页面 (kamacoder.com)）

【提示：如果不想看文字介绍，可以直接跳转到C++编码部分】

【设计模式大纲】

【简介】

-- 什么是中介者模式 （第16种模式）

中介者模式（Mediator Pattern）也被称为调停者模式，是⼀种⾏为型设计模式，它通过⼀个中介对象来封装⼀组对象之间的交互，从⽽使这些对象不需要直接相互引⽤。这样可以降低对象之间的耦合度，使系统更容易维护和扩展。
当⼀个系统中的对象有很多且多个对象之间有复杂的相互依赖关系时，其结构图可能是下⾯这样的。

这种依赖关系很难理清，这时我们可以引⼊⼀个中介者对象来进⾏协调和交互。中介者模式可以使得系统的⽹状结构变成以中介者为中⼼的星形结构，每个具体对象不再通过直接的联系与另⼀个对象发⽣相互作⽤，⽽是通过“中介者”对象与另⼀个对象发⽣相互作⽤。

【基本结构】

中介者模式包含以下⼏个基本角色：

抽象中介者（Mediator）：定义中介者的接⼝，⽤于各个具体同事对象之间的通信。
具体中介者（Concrete Mediator）：实现抽象中介者接⼝，负责协调各个具体同事对象的交互关系，它需要知道所有具体同事类，并从具体同事接收消息，向具体同事对象发出命令。
抽象同事类（Colleague）：定义同事类的接⼝，维护⼀个对中介者对象的引⽤，⽤于通信。
具体同事类（Concrete Colleague）：实现抽象同事类接⼝，每个具体同事类只知道⾃⼰的⾏为，⽽不了解其他同事类的情况，因为它们都需要与中介者通信，通过中介者协调与其他同事对象的交互。

【简易实现 - Java】

以Java代码先作以说明：

1. 抽象中介者

// 抽象中介者
public abstract class Mediator {
    void register(Colleague colleague);
    // 定义⼀个抽象的发送消息⽅法
    public abstract void send(String message, Player player);
}

2. 具体中介者

// 具体中介者
public class ConcreteMediator extends Mediator {
    private List<Colleague> colleagues = new ArrayList<>();

    public void register((Colleague colleague) {
        colleagues.add(colleague);
    }

    @Override
    public void send(String message, Colleague colleague) {
        for (Colleague c : colleagues) {
            // 排除发送消息的同事对象
            if (c != colleague) {
                c.receive(message);
            }
        }
    }
}

3. 同事对象

// 同事对象
abstract class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
    // 发送消息
    public abstract void send(String message);
    // 接收消息
    public abstract void receive(String message);
}

4. 具体同事对象1

// 具体同事对象1
class ConcreteColleague1 extends Colleague {
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }
    @Override
    public void send(String message) {
        mediator.send(message, this);
    }
    @Override
    public void receive(String message) {
        System.out.println("ConcreteColleague1 received: " + message);
    }
}

5. 具体同事对象2

// 具体同事对象2
class ConcreteColleague2 extends Colleague {
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }
    @Override
    public void send(String message) {
        mediator.send(message, this);
    }
    @Override
    public void receive(String message) {
        System.out.println("ConcreteColleague2 received: " + message);
    }
}

6. 客户端

/**
* @version Copyright (c) 2024 NCDC, Servo。 Unpublished - All rights reserved
* @file MediatorMode.hpp
* @brief 中介者模式
* @autor 写代码的小恐龙er
* @date 2024/01/18
*/

// 客户端
public class Main{
    public static void main(String[] args) {
    // 创建中介者
    Mediator mediator = new ConcreteMediator();
    // 创建同事对象
    Colleague colleague1 = new ConcreteColleague1(mediator);
    Colleague colleague2 = new ConcreteColleague2(mediator);
    // 注册同事对象到中介者
    mediator.register(colleague1);
    mediator.register(colleague2);
    // 同事对象之间发送消息
    colleague1.send("Hello from Colleague1!");
    colleague2.send("Hi from Colleague2!");
    }
}

【使用场景】

中介者模式使得同事对象不需要知道彼此的细节，只需要与中介者进⾏通信，简化了系统的复杂度，也降低了各对象之间的耦合度，但是这也会使得中介者对象变得过于庞⼤和复杂，如果中介者对象出现问题，整个系统可能会受到影响。中介者模式适⽤于当系统对象之间存在复杂的交互关系或者系统需要在不同对象之间进⾏灵活的通信时使⽤，可以使得问题简化，

【C++编码部分】

1. 题目描述

小明正在设计一个简单的多人聊天室系统，有多个用户和一个聊天室中介者，用户通过中介者进行聊天，请你帮他完成这个系统的设计。

2. 输入描述

第一行包括一个整数N,表示用户的数量（1 <= N <= 100) 第二行是N个用户，比如User1 User2 User3，用空格分隔第三行开始，每行包含两个字符串，表示消息的发出者和消息内容，用空格分隔；

3. 输出描述

对于每个用户，输出一行，包含该用户收到的所有消息内容。

4. C++编码

/**
* @version Copyright (c) 2024 NCDC, Servo。 Unpublished - All rights reserved
* @file MediatorMode.hpp
* @brief 中介者模式
* @autor 写代码的小恐龙er
* @date 2024/01/18
*/

#include <iostream>
#include <string>
#include <vector>
#include <map>

using namespace std;

// 前置声明

// 抽象中介者类 -- 定义中介者的接⼝，⽤于各个具体同事对象之间的通信
class ChatRoomMediator;
// 具体中介者类 -- 实现抽象中介者接⼝，负责协调各个具体同事对象的交互关系
class ChatRoomMediatorImpl;
// 抽象同事类 -- 定义同事类的接⼝，维护⼀个对中介者对象的引⽤，⽤于通信
class ChatUser;
// 具体同事类 -- 实现抽象同事类接⼝，每个具体同事类只知道⾃⼰的⾏为
class ConcreteChatUser;

// 类的定义

// 抽象中介者类
class ChatRoomMediator
{
// 成员接口函数
public:
    // 获取所有的同事类
    virtual std::map<string, ChatUser*> GetUsers() = 0;
    // 添加同事至中介类
    virtual void AddUser(ChatUser *user) = 0;
    // 中介者发送信息 至其他的所有用户
    virtual void SendMessage(string sender, string message) = 0;
    
};

// 抽象同事类 -- 接口
class ChatUser
{
// 成员函数接口
public:    
    // 获取当前的同事姓名
    virtual string GetName() = 0;
    
    // 发送信息至其他人 通过 中介者来代理
    virtual void SendMessage(string message) = 0;
    
    // 接收信息函数接口
    virtual void ReceiveMessage(string sender, string message) = 0;
    
    // 获取所有的信息集
    virtual std::vector<string> GetAllMessages() = 0;
    
    // 将接收到的信息存放至信息集中
protected:
    virtual void AddRecvMessageIntoVec(string message) = 0;
    
};

// 具体中介者类 
class ChatRoomMediatorImpl : public ChatRoomMediator
{
// 成员数据
private:
    std::map <string, ChatUser*> _chatUsers;
// 成员函数接口
public:
    // 获取所有的同事类 重载
    std::map<string, ChatUser*> GetUsers() override{
        return _chatUsers;
    }
    // 添加同事至中介类 重载
    void AddUser(ChatUser *user) override{
        _chatUsers.insert(std::pair<string, ChatUser*>(user->GetName(), user));
    }
    // 中介者发送信息 至其他的所有用户 函数重载
    void SendMessage(string sender, string message) override{
        for(map<string, ChatUser*>::iterator it = _chatUsers.begin(); it != _chatUsers.end(); it++){
            if(it->first != sender){
                it->second->ReceiveMessage(sender, message);
            }
        }
    }
};

// 具体同事类 
class ConcreteChatUser : public ChatUser
{
// 成员数据
private:
    // 用户姓名
    string _userName;
    // 中介者
    ChatRoomMediator * _mediator;
    // 所有接收到的信息
    std::vector<string> _recvMessages;
// 成员函数接口    
public:
    ConcreteChatUser(string name, ChatRoomMediator *mediator) { 
        this->_userName = name;
        this->_mediator = mediator;
        this->_mediator->AddUser(this);
    }
        // 获取当前的同事姓名
    string GetName() override {
        return _userName;
    }
    
    // 发送信息至其他人 通过 中介者来代理
    void SendMessage(string message) override {
        // 通过中介者去发送信息
        _mediator->SendMessage(_userName, message);
    }
    
    // 接收信息函数接口
    void ReceiveMessage(string sender, string message) override{
        string messages = _userName + " received: " + message;
        std::cout << messages << endl;
    }
    
    // 获取所有的信息集
    std::vector<string> GetAllMessages() override {
        return _recvMessages;
    }
    
    // 将接收到的信息存放至信息集中
protected:
    void AddRecvMessageIntoVec(string message) override{
        _recvMessages.push_back(message);
    }
};


int main()
{
    // 用户数量
    int userNum = 0;
    std::cin >> userNum;
    // 保存所有的用户
    std::vector<string> usersV;
    usersV.resize(userNum);
    
    for(int i = 0; i < userNum; i++){
        std::cin >> usersV[i];
    }
    
    // 抽象中介者
    ChatRoomMediator *mediator = new ChatRoomMediatorImpl();
    // 抽象用户类
    ChatUser *user = nullptr;
    // 在中介者类中添加所有的用户类
    // 遍历
    for(int i = 0; i < userNum; i++){
        // 构造具体的用户类
        user = new ConcreteChatUser(usersV[i], mediator);
    }
    // 此时已经在中介者类中添加了所有的用户
    
    // 遍历 去发送信息
    for(int i = 0; i < userNum; i++){
        // 获取发送者 和 消息
        string senderName = "";
        string sendMessage = "";
        // 输入
        std:: cin >> senderName >> sendMessage;
        // 用户通过中介者去发送消息
        mediator->SendMessage(senderName, sendMessage);
    }
    
    
    // 析构
    if(user != nullptr){
        delete user;
        user = nullptr;
    }
    delete mediator;
    mediator = nullptr;
    return 0;
    
}

【扩展：和代理模式的区别】

中介者模式（Mediator Pattern）和代理模式（Proxy Pattern) 在某些表述上有些类似，但是他们是完全不同的两个设计模式，中介者模式的⽬的是降低系统中各个对象之间的直接耦合，通过引⼊⼀个中介者对象，使对象之间的通信集中在中介者上。而在代理模式中，客户端通过代理与⽬标对象进⾏通信。代理可以在调⽤⽬标对象的⽅法前后进⾏⼀些额外的操作，其⽬的是控制对对象的访问，它们分别解决了不同类型的问题。

......

To be continued.