设计模式——中介者模式

中介者模式(Mediator)

  用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使得耦合松散，而且可以独立地改变它们之间的交互。

  虽然将一个系统分割成许多类对象可以增加程序的复用性，但是对象之间的相互连接又降低了程序的复用性。大量的连接使得一个对象不可能在没有其他对象支持的情况下工作，系统表现为一个不可分割的整体，类之间的关系千丝万缕，对系统进行任何大的改动都会并比较困难。

• **迪米特法则：**如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。

  Colleague叫做抽象同事类，而ConcreteColleague是具体同事类，每个具体同事只知道自己的行为，而不了解其他同事的情况，但是它们都认识中介者对象。Mediator是抽象中介者，定义了同事对象到中介者对象的接口。ConcreteMediator是具体中介者对象，实现抽象类的方法，需要知道所有具体的同事类，并从具体同事接受消息，向具体同事对象发出命令。

代码实现如下

#include <iostream>
#include <string>

using namespace std;

class Colleague;

// Mediator类 抽象中介
class Mediator
{
public:
    virtual void Send(string message, Colleague *colleague) = 0;
};

// Colleague类 抽象同事类
class Colleague
{
public:
    // 构造函数得到中介者对象
    Colleague(Mediator *mediator) : mediator_(mediator) {}

protected:
    Mediator *mediator_;
};

// ConcreteColleague类 具体同事类
class ConcreteColleague1 : public Colleague
{
public:
    ConcreteColleague1(Mediator *mediator) : Colleague(mediator) {}

    void send(string message)
    {
        mediator_->Send(message, this);
    }

    void Notify(string message)
    {
        cout << "同事1得到消息： " + message << endl;
    }
};

class ConcreteColleague2 : public Colleague
{
public:
    ConcreteColleague2(Mediator *mediator) : Colleague(mediator) {}

    void send(string message)
    {
        mediator_->Send(message, this);
    }

    void Notify(string message)
    {
        cout << "同事2得到消息： " + message << endl;
    }
};

// ConccreteMediator 具体中介类
class ConcreteMediator : public Mediator
{
public:
    void SetColleague1(ConcreteColleague1 *colleague)
    {
        colleague1 = colleague;
    }

    void SetColleague2(ConcreteColleague2 *colleague)
    {
        colleague2 = colleague;
    }

    void Send(string message, Colleague *colleague) override
    {
        if (colleague == colleague1)
        {
            colleague2->Notify(message);
        }
        else
        {
            colleague1->Notify(message);
        }
    }

private:
    // 具体中介应该直到所有的具体同事
    ConcreteColleague1 *colleague1 = nullptr;
    ConcreteColleague2 *colleague2 = nullptr;
};

// 客户端代码
void Client()
{
    ConcreteMediator m;

    // 让两个具体同时类认识中介者对象
    ConcreteColleague1 c1(&m);
    ConcreteColleague2 c2(&m);

    m.SetColleague1(&c1);
    m.SetColleague2(&c2);

    c1.send("吃了吗？");
    c2.send("没呢，你请客？");
}

int main()
{
    Client();

    return 0;
}

输出

同事2得到消息： 吃了吗？
同事1得到消息： 没呢，你请客？

中介者模式的优缺点

优点

1. 减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator
2. 将对象如何协作进行了抽象，将中介作为独立的概念并进行了抽象封装在一个对象中，这样不同对象之间的交互可以由一个中介来完成，可以站在更宏观的层面上看待系统。

缺点：

1. 由于ConcreteMediator控制了集中化，把交互的复杂性变成了中介者的复杂性，随着ConcreteColleague类的增加，ConcreteMediator的实现将会变得非常复杂。

何时应用？

1. 中介者模式一般应用于一组对象已经定义良好，但是用复杂的方式进行交互的场合。
2. 以及想定制一个分布在多个类中的行为，而又不想生成太多的子类的场合