设计模式之中介者模式

最新推荐文章于 2025-07-29 21:02:44 发布

编程智界

最新推荐文章于 2025-07-29 21:02:44 发布

阅读量953

点赞数 20

CC 4.0 BY-SA版权

文章标签：设计模式中介者模式 microsoft

本文链接：https://blog.youkuaiyun.com/karl2000/article/details/138556994

问题背景

在开发一个复杂的图形用户界面（GUI）时，我们常常遇到多个组件（如按钮、文本框、标签等）需要相互通信的问题。如果每个组件都直接与其他组件通信，那么随着组件数量的增加，整个系统的复杂性将急剧上升，变得难以维护和扩展。为了解决这一问题，我们可以引入中介者模式，通过一个中心的中介者来管理所有组件间的交互，从而简化通信结构。

问题分析

问题背景和需求：
在没有中介者的情况下，每个组件都可能需要了解其他组件的详情，这不仅使得组件之间的耦合度增加，而且每增加一个新组件都可能需要修改其他组件的代码，这显然不是一个可持续的做法。
中介者模式的适用性：
中介者模式通过引入一个中介者对象，让所有的组件不再直接交互，而是通过中介者进行间接交互。这样，任何组件间的通信都可以通过中介者来协调，从而降低了系统的复杂性，增强了系统的可扩展性。
设计类结构和接口：

中介者接口（Mediator）：定义了用于各个组件通信的接口方法。
具体中介者类（ConcreteMediator）：实现中介者接口，协调各个具体组件的交互。
组件接口（Component）：定义了组件的基本功能和接受中介者的方法。
具体组件类（ConcreteComponent）：如Button, TextBox, Label等，这些具体的组件通过中介者来进行交互。

代码部分

定义中介者和组件接口：

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

// 前向声明
class Mediator;

// 组件接口
class Component {
protected:
    Mediator* mediator;
public:
    Component(Mediator* m = nullptr) : mediator(m) {}
    virtual void setMediator(Mediator* m) {
        mediator = m;
    }
    virtual void doAction() = 0;
    virtual ~Component() {}
};

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

// 具体组件类
class Button : public Component {
public:
    void doAction() override {
        std::cout << "Button pressed." << std::endl;
        mediator->notify(this, "ButtonPress");
    }
};

class TextBox : public Component {
public:
    void doAction() override {
        std::cout << "Text entered." << std::endl;
        mediator->notify(this, "TextEnter");
    }
};

class Label : public Component {
public:
    void doAction() override {
        std::cout << "Label updated." << std::endl;
        mediator->notify(this, "LabelUpdate");
    }
};

// 具体中介者
class DialogDirector : public Mediator {
private:
    std::map<std::string, Component*> components;
public:
    void addComponent(std::string id, Component* component) {
        components[id] = component;
        component->setMediator(this);
    }
    void notify(Component* sender, std::string event) override {
        // 逻辑来处理不同组件的事件
        if (event == "ButtonPress") {
            std::cout << "Mediator reacts on ButtonPress and triggers actions." << std::endl;
            components["Label"]->doAction();  // 假设按按钮后更新标签
        }
    }
};

int main() {
    DialogDirector director; // 创建中介者实例

    // 创建组件并注册到中介者
    Button *button = new Button();
    TextBox *textBox = new TextBox();
    Label *label = new Label();

    director.addComponent("Button", button);
    director.addComponent("TextBox", textBox);
    director.addComponent("Label", label);

    // 模拟用户交互
    std::cout << "User interacts with the GUI:" << std::endl;
    button->doAction();  // 用户点击按钮
    textBox->doAction(); // 用户输入文本
    label->doAction();   // 更新标签

    // 清理资源
    delete button;
    delete textBox;
    delete label;

    return 0;
}

代码分析和总结

元素类与中介者的互动：

每个具体的组件类（Button, TextBox, Label）都通过中介者进行通信。当组件执行了某个动作时，它通过调用中介者的notify方法，将控制权交给中介者。
这种设计允许组件保持简单和专注于自己的功能，同时将所有的交互逻辑委托给中介者处理。

中介者的作用和优势：

中介者DialogDirector充当了组件之间交互的中心点。它根据从组件接收到的通知来执行相应的逻辑，如响应按钮点击、文本输入等。
这种集中管理交互的方式大大简化了组件之间的依赖关系，降低了系统的耦合度，使得组件更容易理解、维护和扩展。

代码维护和扩展性：

中介者模式使得新增或修改组件的交互变得更加简单，因为这些改变主要集中在中介者的逻辑中，而不需要修改组件本身。
系统的可扩展性也因为有了中介者这个单一的调整点而提高，特别是在需要多个组件协同工作的复杂系统中。

潜在的不足：

中介者模式可能导致中介者本身过于复杂，尤其是在处理大量组件和复杂交互逻辑时。这可能会使中介者成为系统中的一个瓶颈，难以管理和维护。
此外，如果中介者的设计和实现不当，它可能会违反单一职责原则，因为它处理了所有组件之间的交互。

中介者模式的编程要点可以归纳为以下几个关键方面：

定义中介者接口：创建一个中介者接口（如 Mediator），定义用于通知中介者的方法（如 notify()）。这个方法通常包括一个发送者和一个事件类型，使中介者可以根据事件的来源和类型来执行相应的逻辑。
实现具体中介者：实现具体的中介者类（如 DialogDirector）。这个类包含了管理和协调各个具体组件的逻辑。中介者通常会持有对所有组件的引用，以便根据接收到的通知来调用相应组件的方法。
定义组件接口：定义一个组件接口（如 Component），其中包括设置中介者的方法（setMediator()）和定义组件行为的方法（如 doAction()）。这使得所有具体组件都能通过中介者接口与其他组件通信。
实现具体组件类：实现具体组件类（如 Button, TextBox, Label），继承自组件接口，并实现相应的方法。在组件的行为方法中（如 doAction()），除了执行自身的行为外，还可能通过中介者来通知其他组件或请求其他组件的服务。
组件注册至中介者：在系统初始化或运行时，创建具体组件实例并将它们注册到中介者中。这通常涉及将组件添加到中介者持有的容器中，并设置相应的中介者实例到组件中。
事件驱动的交互：中介者根据从组件接收的事件来驱动整个应用的流程。例如，一个按钮点击事件可能会通过中介者触发一系列的更新操作在其他组件上。
降低组件间耦合：中介者模式通过使组件不直接相互调用而是通过中介者来进行交互，降低了系统内部各组件间的耦合度。这有助于改善系统的可维护性和扩展性。
集中控制交互逻辑：所有的组件交互逻辑都被集中在中介者中管理，这使得这些逻辑易于监控和修改，但也可能导致中介者过于复杂。