当前位置：首页 > article >正文

C++实现设计模式---中介者模式 (Mediator)

article 2025/1/18 21:41:55

中介者模式 (Mediator)

中介者模式 是一种行为型设计模式，它用一个中介对象来封装一组对象之间的交互。中介者通过协调多个对象之间的通信，避免对象之间的直接依赖，从而实现对象之间的松耦合。

意图

通过引入一个中介者对象，减少对象之间的直接依赖，从而降低耦合性。
中介者负责管理和协调对象之间的通信。

使用场景

对象之间的交互变得复杂：
- 如果对象之间存在大量的直接引用和交互，可以使用中介者模式减少耦合。
希望解耦多个对象：
- 通过中介者，避免对象之间的直接依赖。
需要集中控制交互：
- 需要通过一个中心对象协调和控制所有对象的行为。

参与者角色

中介者接口 (Mediator)
- 定义对象之间通信的接口。
具体中介者 (ConcreteMediator)
- 实现中介者接口，负责具体的通信和协调。
同事类 (Colleague)
- 定义与中介者通信的接口，所有同事类通过中介者进行通信。
具体同事类 (ConcreteColleague)
- 实现同事类的行为，与中介者进行交互。

示例代码

以下代码展示了中介者模式的实现，模拟一个聊天室中的用户通过中介者进行通信的场景。

#include <iostream>
#include <string>
#include <vector>
#include <memory>

// 前置声明中介者
class Mediator;

// 同事类接口
class Colleague {
protected:
    Mediator* mediator; // 中介者指针
    std::string name;   // 同事名称

public:
    Colleague(Mediator* mediator, std::string name) : mediator(mediator), name(std::move(name)) {}
    virtual ~Colleague() = default;

    // 接收消息
    virtual void receiveMessage(const std::string& sender, const std::string& message) = 0;

    // 发送消息
    virtual void sendMessage(const std::string& message) = 0;

    std::string getName() const {
        return name;
    }
};

// 中介者接口
class Mediator {
public:
    virtual ~Mediator() = default;

    // 注册同事
    virtual void addColleague(std::shared_ptr<Colleague> colleague) = 0;

    // 转发消息
    virtual void relayMessage(const std::string& sender, const std::string& message) = 0;
};

// 具体中介者
class ChatMediator : public Mediator {
private:
    std::vector<std::shared_ptr<Colleague>> colleagues; // 同事列表

public:
    void addColleague(std::shared_ptr<Colleague> colleague) override {
        colleagues.push_back(std::move(colleague));
    }

    void relayMessage(const std::string& sender, const std::string& message) override {
        for (const auto& colleague : colleagues) {
            if (colleague->getName() != sender) {
                colleague->receiveMessage(sender, message); // 转发消息给其他同事
            }
        }
    }
};

// 具体同事类
class User : public Colleague {
public:
    User(Mediator* mediator, std::string name) : Colleague(mediator, std::move(name)) {}

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

    void sendMessage(const std::string& message) override {
        std::cout << name << " 发送消息: " << message << "
";
        mediator->relayMessage(name, message); // 通过中介者发送消息
    }
};

// 客户端代码
int main() {
    // 创建中介者
    auto chatMediator = std::make_shared<ChatMediator>();

    // 创建用户
    auto user1 = std::make_shared<User>(chatMediator.get(), "Alice");
    auto user2 = std::make_shared<User>(chatMediator.get(), "Bob");
    auto user3 = std::make_shared<User>(chatMediator.get(), "Charlie");

    // 注册用户到中介者
    chatMediator->addColleague(user1);
    chatMediator->addColleague(user2);
    chatMediator->addColleague(user3);

    // 用户发送消息
    user1->sendMessage("大家好！");
    user2->sendMessage("你好，Alice！");
    user3->sendMessage("欢迎加入聊天室！");

    return 0;
}

代码解析

1. 中介者接口 (Mediator)

定义了对象之间通信的接口。
包含方法 addColleague 用于注册同事对象，relayMessage 用于转发消息。

class Mediator {
public:
    virtual ~Mediator() = default;
    virtual void addColleague(std::shared_ptr<Colleague> colleague) = 0;
    virtual void relayMessage(const std::string& sender, const std::string& message) = 0;
};

2. 具体中介者 (ChatMediator)

实现中介者接口，负责管理同事对象并转发消息。

class ChatMediator : public Mediator {
private:
    std::vector<std::shared_ptr<Colleague>> colleagues;
public:
    void addColleague(std::shared_ptr<Colleague> colleague) override {
        colleagues.push_back(std::move(colleague));
    }

    void relayMessage(const std::string& sender, const std::string& message) override {
        for (const auto& colleague : colleagues) {
            if (colleague->getName() != sender) {
                colleague->receiveMessage(sender, message);
            }
        }
    }
};

3. 同事类接口 (Colleague)

定义与中介者通信的接口。
包含方法 sendMessage 和 receiveMessage。

class Colleague {
protected:
    Mediator* mediator;
    std::string name;
public:
    Colleague(Mediator* mediator, std::string name) : mediator(mediator), name(std::move(name)) {}
    virtual ~Colleague() = default;
    virtual void receiveMessage(const std::string& sender, const std::string& message) = 0;
    virtual void sendMessage(const std::string& message) = 0;
    std::string getName() const { return name; }
};

4. 具体同事类 (User)

实现同事类的行为，与中介者进行交互。

class User : public Colleague {
public:
    User(Mediator* mediator, std::string name) : Colleague(mediator, std::move(name)) {}
    void receiveMessage(const std::string& sender, const std::string& message) override {
        std::cout << name << " 收到来自 " << sender << " 的消息: " << message << "
";
    }
    void sendMessage(const std::string& message) override {
        std::cout << name << " 发送消息: " << message << "
";
        mediator->relayMessage(name, message);
    }
};