中介者模式

中介模式

介绍

中介模式的设计思想跟中间层很像，通过引入中介这个中间层，将一组对象之间的交互关系（或者说依赖关系）从多对多（网状关系）转换为一对多（星状关系）。原来一个对象要跟n个对象交互，现在只需要跟一个中介对象交互，从而最小化对象之间的交互关系，降低了代码的复杂度，提高了代码的可读性和可维护性。

中介模式定义了一个单独的（中介）对象，来封装一组对象之间的交互。将这组对象之间的交互委派给与中介对象交互，来避免对象之间的直接交互。

定义

聊天室系统将包括用户（同事类）和中介者（聊天室）两个主要组件。

用户可以发送消息给聊天室，聊天

中介层

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

// 具体中介者
class ConcreteMediator : public Mediator {
public:
    void addColleague(Colleague* colleague) {
        colleagues.push_back(colleague);
    }

    virtual void sendMessage(const std::string& message, Colleague* colleague) override {
        for (Colleague* c : colleagues) {
            if (c != colleague) {
                c->receiveMessage(message);
            }
        }
    }

private:
    std::vector<Colleague*> colleagues;
};

同事类

// 抽象同事类
class Colleague {
public:
    Colleague(Mediator* mediator, const std::string& name) : mediator(mediator), name(name) {}

    virtual void sendMessage(const std::string& message) = 0;
    virtual void receiveMessage(const std::string& message) = 0;

protected:
    Mediator* mediator;
    std::string name;
};

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

    virtual void sendMessage(const std::string& message) override {
        std::cout << name << " 发送消息: " << message << std::endl;
        mediator->sendMessage(message, this);
    }

    virtual void receiveMessage(const std::string& message) override {
        std::cout << name << " 收到消息: " << message << std::endl;
    }
};

调用

int main() {
    ConcreteMediator mediator;

    ConcreteColleague user1(&mediator, "User 1");
    ConcreteColleague user2(&mediator, "User 2");
    ConcreteColleague user3(&mediator, "User 3");

    mediator.addColleague(&user1);
    mediator.addColleague(&user2);
    mediator.addColleague(&user3);

    user1.sendMessage("Hello, everyone!");
    user2.sendMessage("Hi there!");
    user3.sendMessage("Greetings!");

    return 0;
}

效果

./mediator   
User 1 发送消息: Hello, everyone!
User 2 收到消息: Hello, everyone!
User 3 收到消息: Hello, everyone!
User 2 发送消息: Hi there!
User 1 收到消息: Hi there!
User 3 收到消息: Hi there!
User 3 发送消息: Greetings!
User 1 收到消息: Greetings!
User 2 收到消息: Greetings!

回顾

中介模式的设计思想跟中间层很像，通过引入中介这个中间层，将一组对象之间的交互关系（或者依赖关系）从多对多（网状关系）转换为一对多（星状关系）。原来一个对象要跟n个对象交互，现在只需要跟一个中介对象交互，从而最小化对象之间的交互关系，降低了代码的复杂度，提高了代码的可读性和可维护性。

中介模式 VS 观察者模式

前面讲观察者模式的时候，我们讲到，观察者模式有多种实现方式。虽然经典的实现方式没法彻底解耦观察者和被观察者，观察者需要注册到被观察者中，被观察者状态更新需要调用观察者的update()方法。但是，在跨进程的实现方式中，我们可以利用消息队列实现彻底解耦，观察者和被观察者都只需要跟消息队列交互，观察者完全不知道被观察者的存在，被观察者也完全不知道观察者的存在。

我们前面提到，中介模式也是为了解耦对象之间的交互，所有的参与者都只与中介进行交互。而观察者模式中的消息队列，就有点类似中介模式中的“中介”，观察者模式的中观察者和被观察者，就有点类似中介模式中的“参与者”。那问题来了：中介模式和观察者模式的区别在哪里呢？什么时候选择使用中介模式？什么时候选择使用观察者模式呢？

在观察者模式中，尽管一个参与者既可以是观察者，同时也可以是被观察者，但是，大部分情况下，交互关系往往都是单向的，一个参与者要么是观察者，要么是被观察者，不会兼具两种身份。也就是说，在观察者模式的应用场景中，参与者之间的交互关系比较有条理。

而中介模式正好相反。只有当参与者之间的交互关系错综复杂，维护成本很高的时候，我们才考虑使用中介模式。毕竟，中介模式的应用会带来一定的副作用，前面也讲到，它有可能会产生大而复杂的上帝类。除此之外，如果一个参与者状态的改变，其他参与者执行的操作有一定先后顺序的要求，这个时候，中介模式就可以利用中介类，通过先后调用不同参与者的方法，来实现顺序的控制，而观察者模式是无法实现这样的顺序要求的。

观察者模式和中介模式都是为了实现参与者之间的解耦，简化交互关系。两者的不同在于应用场景上。在观察者模式的应用场景中，参与者之间的交互比较有条理，一般都是单向的，一个参与者只有一个身份，要么是观察者，要么是被观察者。而在中介模式的应用场景中，参与者之间的交互关系错综复杂，既可以是消息的发送者、也可以同时是消息的接收者。

代码code