C++ 中介者模式详解

循以下设计原则：

单一职责原则：将对象间的交互集中到中介者中
迪米特法则：减少对象间的直接通信
开闭原则：可以新增中介者而不修改现有组件

主要优点

降低耦合：减少对象间的直接依赖
集中控制：将交互逻辑集中到中介者
简化维护：交互关系更容易理解和修改
复用性：组件可以更容易地被复用

模式结构

主要组件

Mediator（中介者接口）
- 定义与各组件通信的接口
ConcreteMediator（具体中介者）
- 实现中介者接口
- 协调各组件之间的交互
- 知道所有组件及其用途
Component（组件）
- 每个组件都知道其中介者对象
- 组件间不直接通信，而是通过中介者

完整代码示例

复制代码

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

// 前置声明
class Component;

// ==================== 中介者接口 ====================
class Mediator {
public:
    virtual void notify(Component* sender, const std::string& event) const = 0;
    virtual ~Mediator() = default;
};

// ==================== 组件基类 ====================
class Component {
protected:
    Mediator* mediator_;
    
public:
    explicit Component(Mediator* mediator = nullptr) : mediator_(mediator) {}
    
    void setMediator(Mediator* mediator) {
        mediator_ = mediator;
    }
    
    virtual ~Component() = default;
};

// ==================== 具体组件 ====================
class Button : public Component {
    std::string name_;
    
public:
    explicit Button(const std::string& name, Mediator* mediator = nullptr)
        : Component(mediator), name_(name) {}
    
    void click() {
        std::cout << name_ << " 被点击" << std::endl;
        if (mediator_) {
            mediator_->notify(this, "click");
        }
    }
};

class TextBox : public Component {
    std::string text_;
    
public:
    explicit TextBox(Mediator* mediator = nullptr) : Component(mediator) {}
    
    void setText(const std::string& text) {
        text_ = text;
        std::cout << "文本框内容设置为: " << text << std::endl;
        if (mediator_) {
            mediator_->notify(this, "text_changed");
        }
    }
    
    std::string getText() const { return text_; }
};

class CheckBox : public Component {
    bool checked_ = false;
    
public:
    explicit CheckBox(Mediator* mediator = nullptr) : Component(mediator) {}
    
    void check() {
        checked_ = !checked_;
        std::cout << "复选框状态: " << (checked_ ? "选中" : "未选中") << std::endl;
        if (mediator_) {
            mediator_->notify(this, checked_ ? "checked" : "unchecked");
        }
    }
    
    bool isChecked() const { return checked_; }
};

// ==================== 具体中介者 ====================
class AuthenticationDialog : public Mediator {
    Button* loginButton_;
    Button* cancelButton_;
    TextBox* usernameTextBox_;
    TextBox* passwordTextBox_;
    CheckBox* rememberMeCheckBox_;
    
public:
    AuthenticationDialog(
        Button* loginButton,
        Button* cancelButton,
        TextBox* usernameTextBox,
        TextBox* passwordTextBox,
        CheckBox* rememberMeCheckBox)
        : loginButton_(loginButton),
          cancelButton_(cancelButton),
          usernameTextBox_(usernameTextBox),
          passwordTextBox_(passwordTextBox),
          rememberMeCheckBox_(rememberMeCheckBox) {
        
        loginButton_->setMediator(this);
        cancelButton_->setMediator(this);
        usernameTextBox_->setMediator(this);
        passwordTextBox_->setMediator(this);
        rememberMeCheckBox_->setMediator(this);
    }
    
    void notify(Component* sender, const std::string& event) const override {
        if (sender == loginButton_ && event == "click") {
            std::cout << "登录按钮点击 - 尝试登录..." << std::endl;
            if (usernameTextBox_->getText().empty() || passwordTextBox_->getText().empty()) {
                std::cout << "错误: 用户名和密码不能为空" << std::endl;
            } else {
                std::cout << "使用用户名 '" << usernameTextBox_->getText() 
                          << "' 和密码 '" << passwordTextBox_->getText() << "' 登录" << std::endl;
                if (rememberMeCheckBox_->isChecked()) {
                    std::cout << "记住登录状态" << std::endl;
                }
            }
        } else if (sender == cancelButton_ && event == "click") {
            std::cout << "取消按钮点击 - 重置表单" << std::endl;
            usernameTextBox_->setText("");
            passwordTextBox_->setText("");
            rememberMeCheckBox_->check();
        } else if (sender == rememberMeCheckBox_ && (event == "checked" || event == "unchecked")) {
            std::cout << "记住我选项改变: " << event << std::endl;
        } else if ((sender == usernameTextBox_ || sender == passwordTextBox_) 
                  && event == "text_changed") {
            std::cout << "文本改变 - 验证输入..." << std::endl;
        }
    }
};

// ==================== 客户端代码 ====================
int main() {
    std::cout << "=== 中介者模式演示: 登录对话框 ===" << std::endl;
    
    // 创建组件
    Button loginButton("登录");
    Button cancelButton("取消");
    TextBox usernameTextBox;
    TextBox passwordTextBox;
    CheckBox rememberMeCheckBox;
    
    // 创建中介者并关联组件
    AuthenticationDialog dialog(
        &loginButton, 
        &cancelButton, 
        &usernameTextBox, 
        &passwordTextBox, 
        &rememberMeCheckBox);
    
    // 模拟用户交互
    std::cout << "\n用户输入用户名和密码..." << std::endl;
    usernameTextBox.setText("user123");
    passwordTextBox.setText("password");
    
    std::cout << "\n用户点击记住我..." << std::endl;
    rememberMeCheckBox.check();
    
    std::cout << "\n用户点击登录按钮..." << std::endl;
    loginButton.click();
    
    std::cout << "\n用户点击取消按钮..." << std::endl;
    cancelButton.click();
    
    return 0;
}

模式变体

1. 观察者中介者

复制代码

class ObserverMediator : public Mediator {
    std::vector<Component*> components_;
    
public:
    void addComponent(Component* component) {
        components_.push_back(component);
        component->setMediator(this);
    }
    
    void notify(Component* sender, const std::string& event) override {
        for (auto component : components_) {
            if (component != sender) {
                // 通知其他组件
            }
        }
    }
};

2. 单例中介者

复制代码

class SingletonMediator : public Mediator {
    static SingletonMediator* instance_;
    SingletonMediator() = default;
    
public:
    static SingletonMediator* getInstance() {
        if (!instance_) {
            instance_ = new SingletonMediator();
        }
        return instance_;
    }
    
    void notify(Component* sender, const std::string& event) override {
        // 实现通知逻辑
    }
};

实际应用场景

GUI开发：如示例中的对话框组件交互
聊天系统：聊天室作为用户间通信的中介
航空管制：塔台协调飞机间的通信
工作流系统：协调多个处理步骤
游戏开发：游戏对象间的交互协调