C++设计模式——Mediator中介者模式

一,中介者模式的定义

中介者模式是一种行为型设计模式。它通过一个中介者对象将多个对象之间的交互关系进行封装,使得对象之间的交互需要通过中介者对象来完成。该设计模式的结构很容易理解,以中介者为中心。

中介者模式的设计思想侧重于在对象之间增加一个用来调度的中介。

有了中介者模式,各个对象可以专注于各自的业务处理逻辑,而不需要关心通信的具体实现细节。

中介者模式在现实生活中的抽象实例:

航空管制系统:航空管制系统作为中介者,协调飞机、航空公司和机场的通信和协作。

交易系统:在金融领域,交易系统将银行、金融机构、客户等各个参与者进行协调,确保资金的安全快速转移。

买房中介:买房中介充当着买卖双方之间的桥梁和调解者的角色,确保双方利益的平衡和交易的顺利进行。

二,中介者模式的结构

中介者模式主要包含以下组件:

1.抽象中介者(Mediator):定义了对象之间相互通信的规则,定义了管理对象和消息通信的统一接口。

2.抽象同事对象(Colleague):是参与通信的各个对象,内部包含对中介者对象的引用。负责将消息发送给中介者,以及接收并处理中介者发来的消息。

3.具体中介者(Concrete Mediator):包含对抽象中介者的具体实现,负责协调各个对象之间的通信,协调的方式以转发消息为主。

4.具体同事对象(Concrete Colleague):包含对抽象同事对象的具体实现。它们之间通过调用中介者的接口进行通信,并接收和处理中介者转发给它们的消息。

组件之间的工作步骤如下:

1.初始化中介者对象。

2.各个同事对象与中介者关联,将中介者对象传递给各个同事对象。

3.同事对象与中介者通信,同事对象调用中介者对象提供的通信接口,由中介者负责将信息转发给目标同事对象。

对应UML类图:

三,中介者模式代码样例

cpp 复制代码
#include <iostream>
#include <string>
#include <vector>

class Colleague;

class Mediator{
public:
    virtual void sendMessage(const std::string& msg, Colleague* colleague) = 0;
    virtual void addColleague(Colleague* colleague) = 0;
};

class Colleague{
public:
    Colleague(Mediator* mediator) : mediator_(mediator) {}
    virtual void sendMessage(const std::string& message) = 0;
    virtual void receiveMessage(const std::string& message) = 0;
protected:
    Mediator* mediator_;
};

class ConcreteMediator : public Mediator{
public:
    void sendMessage(const std::string& msg, Colleague* colleague) override
    {
        for (auto col : colleagues_) {
            if (col != colleague) {
                col->receiveMessage(msg);
            }
        }
    }
    void addColleague(Colleague* colleague) override {
        colleagues_.push_back(colleague);
    }
private:
    std::vector<Colleague*> colleagues_;
};

class ConcreteColleague : public Colleague{
public:
    ConcreteColleague(Mediator* mediator) : Colleague(mediator) {}
    void sendMessage(const std::string& message) override {
        mediator_->sendMessage(message, this);
    }
    void receiveMessage(const std::string& message) override {
        std::cout << "Received message: " << message << std::endl;
    }
};

int main() {
    Mediator* mediator = new ConcreteMediator();
    Colleague* colleague1 = new ConcreteColleague(mediator);
    Colleague* colleague2 = new ConcreteColleague(mediator);

    mediator->addColleague(colleague1);
    mediator->addColleague(colleague2);

    colleague1->sendMessage("Hello from colleague1");
    colleague2->sendMessage("Hello from colleague2");

    delete colleague1;
    delete colleague2;
    delete mediator;
    return 0;
}

运行结果:

bash 复制代码
Received message: Hello from colleague1
Received message: Hello from colleague2

四,中介者模式的应用场景

事件驱动架构:应用程序中,按钮点击等事件不需要直接关联所有处理响应的逻辑,而是通过一个"事件总线"或"消息中间件"来分发消息。

GUI用户界面:在UI组件间传递事件或更新状态时,可以使用中介者模式避免硬编码依赖。

分布式系统:分布式应用中设定一个集中式的服务器作为中介,协调客户端之间的交互。

消息队列:在异步通信场景,发送者和接收者通过一个消息中间件来传递信息,方便解耦和事务管理。

五,中介者模式的优缺点

中介者模式的优点:

降低了对象之间的耦合,易于维护。

可以实现对通信的集中控制。

方便随时修改和消息对应的事件处理。

在不改变原有对象的基础上,可以灵活添加新的消息类型。

中介者模式的缺点:

容易导致对系统的过度设计。

当对象很多时,中介者会变得复杂和难以管理。

通信期间需要额外的调度,性能开销大。

六,代码实战

Demo1:基于中介者模式实现的消息群发功能

cpp 复制代码
#include <iostream>
#include <string>
#include <vector>

class User;

class Mediator {
public:
    virtual void sendMessage(const std::string& message, User* user) = 0;
    virtual void addUser(User* user) = 0;
};

class User {
public:
    User(const std::string& name, Mediator* mediator){
        this->name = name;
        this->mediator = mediator;
    }
    const std::string& getName() const {
        return name;
    }
    void sendMessage(const std::string& message) {
        mediator->sendMessage(message, this);
    }
    virtual void receiveMsg(const std::string& message) = 0;
private:
    std::string name;
    Mediator* mediator;
};

class ChatRoom : public Mediator {
public:
    void addUser(User* user) {
        users.push_back(user);
    }
    void sendMessage(const std::string& message, User* sender) override {
        for (User* user : users) {
            if (user != sender) {
                user->receiveMsg(message);
            }
        }
    }
private:
    std::vector<User*> users;
};

class ChatUser : public User {
public:
    ChatUser(const std::string& name, Mediator* mediator) : User(name, mediator) {}
    void receiveMsg(const std::string& msg) override {
        std::cout << getName() << " received a message: " << msg << std::endl;
    }
};

int main() {
    Mediator* chatRoom = new ChatRoom();
    User* user1 = new ChatUser("User1", chatRoom);
    User* user2 = new ChatUser("User2", chatRoom);
    User* user3 = new ChatUser("User3", chatRoom);

    chatRoom->addUser(user1);
    chatRoom->addUser(user2);
    chatRoom->addUser(user3);
    user1->sendMessage("Hello, everyone!");

    delete user1;
    delete user2;
    delete user3;
    delete chatRoom;
    return 0;
}

运行结果:

bash 复制代码
User2 received a message: Hello, everyone!
User3 received a message: Hello, everyone!

Demo2:模拟的聊天室

cpp 复制代码
#include <iostream>
#include <string>
#include <vector>

using namespace std;

struct ChatRoom {
    virtual void broadcast(string from, string msg) = 0;
    virtual void message(string from, string to, string msg) = 0;
};

struct Person {
    string m_name;
    ChatRoom* m_room{ nullptr };
    vector<string> m_chat_log;
    Person(string n) : m_name(n) {}
    void say(string msg) const {
        m_room->broadcast(m_name, msg);
    }
    void pm(string to, string msg) const {
        m_room->message(m_name, to, msg);
    }
    void receive(string from, string msg) {
        string s{ from + ": \"" + msg + "\"" };
        cout << "[" << m_name << "'s chat session]" << s << "\n";
        m_chat_log.emplace_back(s);
    }
};

struct GoogleChat: ChatRoom
{
    vector<Person*> m_people;
    void broadcast(string from, string msg) {
        for (auto p : m_people)
            if (p->m_name != from)
                p->receive(from, msg);
    }
    void join(Person* p) {
        string join_msg = p->m_name + " joins the chat";
        broadcast("room", join_msg);
        p->m_room = this;
        m_people.push_back(p);
    }
    void message(string from, string to, string msg) {
        auto target = find_if(begin(m_people), end(m_people),
            [&](const Person* p) {
                return p->m_name == to;
            });
        if (target != end(m_people)) (*target)->receive(from, msg);
    }
};

int main() {
    GoogleChat room;
    Person john{ "John" };
    Person jane{ "Jane" };
    room.join(&john);
    room.join(&jane);

    john.say("hi room");
    jane.say("oh, hey john");
    Person simon{ "Simon" };
    room.join(&simon);
    simon.say("hi everyone!");
    jane.pm("Simon", "glad you found us, simon!");
    return EXIT_SUCCESS;
}

运行结果:

bash 复制代码
[John's chat session]room: "Jane joins the chat"
[Jane's chat session]John: "hi room"
[John's chat session]Jane: "oh, hey john"
[John's chat session]room: "Simon joins the chat"
[Jane's chat session]room: "Simon joins the chat"
[John's chat session]Simon: "hi everyone!"
[Jane's chat session]Simon: "hi everyone!"
[Simon's chat session]Jane: "glad you found us, simon!"

七,参考阅读

https://www.geeksforgeeks.org/mediator-design-pattern/

https://www.patterns.dev/vanilla/mediator-pattern/

https://vishalchovatiya.com/posts/mediator-design-pattern-in-modern-cpp/

https://softwarepatterns.com/cpp/mediator-software-pattern-cpp-example

相关推荐
哪 吒2 小时前
最简单的设计模式,抽象工厂模式,是否属于过度设计?
设计模式·抽象工厂模式
Theodore_10222 小时前
4 设计模式原则之接口隔离原则
java·开发语言·设计模式·java-ee·接口隔离原则·javaee
网易独家音乐人Mike Zhou3 小时前
【卡尔曼滤波】数据预测Prediction观测器的理论推导及应用 C语言、Python实现(Kalman Filter)
c语言·python·单片机·物联网·算法·嵌入式·iot
‘’林花谢了春红‘’4 小时前
C++ list (链表)容器
c++·链表·list
----云烟----4 小时前
QT中QString类的各种使用
开发语言·qt
lsx2024064 小时前
SQL SELECT 语句:基础与进阶应用
开发语言
开心工作室_kaic5 小时前
ssm161基于web的资源共享平台的共享与开发+jsp(论文+源码)_kaic
java·开发语言·前端
向宇it5 小时前
【unity小技巧】unity 什么是反射?反射的作用?反射的使用场景?反射的缺点?常用的反射操作?反射常见示例
开发语言·游戏·unity·c#·游戏引擎
武子康5 小时前
Java-06 深入浅出 MyBatis - 一对一模型 SqlMapConfig 与 Mapper 详细讲解测试
java·开发语言·数据仓库·sql·mybatis·springboot·springcloud
转世成为计算机大神5 小时前
易考八股文之Java中的设计模式?
java·开发语言·设计模式