C++中介者模式的实战解析与系统设计应用指南-源码库

C++中介者模式的实战解析与系统设计应用指南

大家好，我是一名有着多年C++开发经验的工程师。今天想和大家深入聊聊中介者模式在实际项目中的应用。记得我第一次接触这个模式时，觉得它就是个简单的解耦工具，直到在一个复杂的消息处理系统中踩了坑，才真正理解了它的威力。

什么是中介者模式？

中介者模式的核心思想很简单：通过引入一个中介者对象来封装一系列对象之间的交互。这样对象之间就不需要显式地相互引用，从而使其耦合松散。在实际项目中，当多个类之间存在复杂的网状关系时，中介者模式就能大显身手。

让我举个现实中的例子：在一个聊天室系统中，如果没有中介者，每个用户都需要维护与其他所有用户的连接，这会导致类之间的依赖关系极其复杂。而引入聊天室服务器作为中介者后，用户只需要与服务器交互，大大简化了系统结构。

中介者模式的核心结构

在中介者模式中，主要包含以下几个角色：

Mediator（抽象中介者）：定义各个同事对象交互的接口
ConcreteMediator（具体中介者）：实现抽象中介者接口，协调各个同事对象
Colleague（同事类）：每个同事类都知道它的中介者对象

下面是一个简单的C++实现示例：


#include 
#include 
#include 

// 前向声明
class Colleague;

// 抽象中介者
class Mediator {
public:
    virtual void send(const std::string& message, Colleague* colleague) = 0;
    virtual ~Mediator() = default;
};

// 同事类基类
class Colleague {
protected:
    Mediator* mediator_;
public:
    Colleague(Mediator* mediator) : mediator_(mediator) {}
    virtual ~Colleague() = default;
};

// 具体同事类A
class ConcreteColleagueA : public Colleague {
public:
    ConcreteColleagueA(Mediator* mediator) : Colleague(mediator) {}
    
    void send(const std::string& message) {
        mediator_->send(message, this);
    }
    
    void receive(const std::string& message) {
        std::cout << "Colleague A received: " << message << std::endl;
    }
};

// 具体同事类B
class ConcreteColleagueB : public Colleague {
public:
    ConcreteColleagueB(Mediator* mediator) : Colleague(mediator) {}
    
    void send(const std::string& message) {
        mediator_->send(message, this);
    }
    
    void receive(const std::string& message) {
        std::cout << "Colleague B received: " << message << std::endl;
    }
};

// 具体中介者
class ConcreteMediator : public Mediator {
private:
    ConcreteColleagueA* colleagueA_;
    ConcreteColleagueB* colleagueB_;
    
public:
    void setColleagueA(ConcreteColleagueA* colleague) {
        colleagueA_ = colleague;
    }
    
    void setColleagueB(ConcreteColleagueB* colleague) {
        colleagueB_ = colleague;
    }
    
    void send(const std::string& message, Colleague* colleague) override {
        if (colleague == colleagueA_) {
            colleagueB_->receive(message);
        } else {
            colleagueA_->receive(message);
        }
    }
};

实战案例：聊天室系统设计

让我分享一个真实的项目经验。我们曾经开发一个企业级即时通讯系统，最初的设计是每个用户直接维护与其他用户的连接。随着用户数量增加，系统变得难以维护。

重构时我们引入了中介者模式：


class ChatUser; // 前向声明

// 聊天室中介者
class ChatRoom : public Mediator {
private:
    std::vector users_;
    
public:
    void addUser(ChatUser* user) {
        users_.push_back(user);
    }
    
    void sendMessage(const std::string& message, ChatUser* sender) override {
        for (auto user : users_) {
            if (user != sender) {
                user->receive(message);
            }
        }
    }
};

class ChatUser : public Colleague {
private:
    std::string name_;
    
public:
    ChatUser(const std::string& name, Mediator* mediator) 
        : Colleague(mediator), name_(name) {}
    
    void send(const std::string& message) {
        std::cout << name_ << " sends: " << message << std::endl;
        mediator_->sendMessage(name_ + ": " + message, this);
    }
    
    void receive(const std::string& message) {
        std::cout << name_ << " receives: " << message << std::endl;
    }
};

踩坑经验与最佳实践

在实际使用中介者模式时，我总结了一些经验教训：

1. 避免中介者变成上帝对象
中介者很容易承担过多职责，变得臃肿。我的建议是将中介者按功能模块拆分，或者使用多个中介者协同工作。

2. 注意性能问题
当中介者需要处理大量对象交互时，可能会成为性能瓶颈。我们在一个高频交易系统中就遇到过这个问题，最终通过引入异步处理和批量操作解决了。

3. 合理设计同事类接口
同事类的接口应该足够通用，但又不能过于抽象。我建议根据具体业务场景来设计，保持接口的简洁性。

中介者模式与其他模式的对比

很多开发者容易混淆中介者模式和观察者模式。简单来说：

观察者模式：一对多的依赖关系，主题变化时通知所有观察者
中介者模式：多对多的复杂交互，通过中介者来协调

在实际项目中，两种模式经常结合使用。比如在中介者内部使用观察者模式来管理事件通知。

系统设计中的应用指南

根据我的经验，以下场景特别适合使用中介者模式：


// GUI系统中的事件处理
class GUIEventMediator {
public:
    void onButtonClick() {
        // 更新文本框
        // 刷新列表
        // 改变状态栏
        // 所有组件更新通过中介者协调
    }
};

// 微服务架构中的API网关
class APIGateway {
public:
    Response handleRequest(Request request) {
        // 路由到相应服务
        // 处理服务间调用
        // 聚合结果返回
    }
};

何时使用中介者模式：