解耦利器：C++20 中介者模式深度剖析与实战指南

在复杂的系统中，对象之间的直接耦合会导致系统难以维护和扩展。中介者模式作为行为型设计模式的一种，旨在解决这个问题。它通过引入一个中介者对象，来封装对象之间的交互，从而降低对象之间的耦合度，提升系统的灵活性和可维护性。例如，一个大型电商系统，包含了订单服务、支付服务、物流服务等多个模块，这些模块之间需要频繁交互。如果没有中介者模式，这些模块将直接互相调用，导致系统耦合度极高。一旦某个模块发生变化，可能需要修改多个其他模块的代码，极大地增加了维护成本。这时候，就可以引入一个中介者对象来协调这些模块之间的交互。

中介者模式的底层原理

中介者模式的核心思想是“用一个中介对象来封装一系列的对象交互”。具体来说，它包含以下几个关键角色：

• 中介者（Mediator）：定义一个接口，用于与各个同事对象通信。
• 具体中介者（ConcreteMediator）：实现中介者接口，协调各个同事对象之间的交互。
• 同事（Colleague）：定义一个抽象类或接口，所有的同事对象都实现或继承它。
• 具体同事（ConcreteColleague）：实现同事接口，通过中介者对象与其他同事对象通信。

其工作流程大致如下：

1. 各个具体同事对象注册到具体中介者对象中。
2. 当一个具体同事对象需要与其他同事对象交互时，它不是直接调用其他同事对象的方法，而是调用中介者对象的方法。
3. 中介者对象根据具体情况，调用相应的同事对象的方法，完成交互。

这种设计方式的好处在于，它将对象之间的交互逻辑集中到了中介者对象中，降低了对象之间的耦合度。当需要修改交互逻辑时，只需要修改中介者对象即可，而不需要修改各个同事对象的代码。

代码示例：模拟聊天室场景

以下代码示例模拟了一个简单的聊天室场景，其中中介者负责协调用户之间的消息发送。

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

// Colleague Interface
class User {
public:
    User(std::string name) : name_(name) {}
    virtual void sendMessage(std::string message) = 0;
    virtual void receiveMessage(std::string message) = 0;
    std::string getName() const { return name_; }

protected:
    std::string name_;
};

// Mediator Interface
class ChatRoomMediator {
public:
    virtual void sendMessage(std::string message, User* user) = 0;
};

// Concrete Colleague
class ConcreteUser : public User {
public:
    ConcreteUser(std::string name, ChatRoomMediator* mediator) : User(name), mediator_(mediator) {}
    void sendMessage(std::string message) override {
        mediator_->sendMessage(message, this);
    }
    void receiveMessage(std::string message) override {
        std::cout << name_ << " received: " << message << std::endl;
    }

private:
    ChatRoomMediator* mediator_;
};

// Concrete Mediator
class ConcreteChatRoom : public ChatRoomMediator {
public:
    void addUser(User* user) {
        users_.push_back(user);
    }
    void sendMessage(std::string message, User* user) override {
        for (User* u : users_) {
            if (u != user) {
                u->receiveMessage(user->getName() + ": " + message);
            }
        }
    }

private:
    std::vector<User*> users_;
};

int main() {
    ConcreteChatRoom* chatRoom = new ConcreteChatRoom();

    ConcreteUser* user1 = new ConcreteUser("Alice", chatRoom);
    ConcreteUser* user2 = new ConcreteUser("Bob", chatRoom);

    chatRoom->addUser(user1);
    chatRoom->addUser(user2);

    user1->sendMessage("Hello Bob!");
    user2->sendMessage("Hi Alice!");

    delete user1;
    delete user2;
    delete chatRoom;

    return 0;
}

实战避坑经验总结

1. 过度使用： 中介者模式并非适用于所有场景。只有在对象之间的交互逻辑非常复杂，且对象之间存在大量的依赖关系时，才适合使用中介者模式。如果对象之间的交互逻辑很简单，或者对象之间没有太多的依赖关系，那么使用中介者模式反而会增加系统的复杂性。
2. 中介者膨胀： 随着系统功能的增加，中介者对象可能会变得非常庞大，包含大量的交互逻辑。这会导致中介者对象难以维护和扩展。为了避免这种情况，可以考虑将中介者对象分解为多个更小的中介者对象，或者使用其他设计模式来简化交互逻辑。例如，可以将部分业务逻辑下沉到各个 Colleague 中。
3. 性能问题： 所有对象之间的交互都需要通过中介者对象进行，这可能会导致性能瓶颈。为了解决这个问题，可以考虑使用缓存、异步消息队列等技术来优化中介者对象的性能。类比于 Nginx 作为反向代理服务器，可以将常用的结果缓存起来，减轻后端服务器的压力，同时提升响应速度。或者使用 Redis 这种内存数据库做缓存，提升性能。
4. 与观察者模式的比较： 中介者模式和观察者模式都是行为型模式，都用于降低对象之间的耦合度。但它们的区别在于，观察者模式是单向的，一个对象的状态变化会通知给多个观察者对象，而中介者模式是双向的，对象之间通过中介者对象进行交互。在选择使用哪种模式时，需要根据具体的场景进行考虑。如果只需要单向通知，那么观察者模式更合适；如果需要双向交互，那么中介者模式更合适。

总而言之，合理使用中介者模式能够有效降低 C++ 系统中对象间的耦合，提升系统的可维护性和扩展性。但需要注意避免过度使用，并关注潜在的性能问题。通过对底层原理的理解和实战经验的积累，才能更好地运用这一强大的设计模式。