【设计模式】——中介者模式

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

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

#include <iostream>

using namespace std;
class Colleague;
//Mediator类，抽象中介者
class Mediator
{
public:
    //定义一个抽象的发送消息的方法，得到同事对象和发送消息
    virtual void Send(string message,Colleague *colleague)=0;
};
//Colleague类 抽象同事类
class Colleague
{
protected:
    Mediator *m_mediator;
public:
    Colleague(Mediator *mediator)
    {
        this->m_mediator=mediator;
    }
};
//ConcreteColleague1和ConcreteColleague2等各种同事对象
class ConcreteColleague1:public Colleague
{
public:
    ConcreteColleague1(Mediator *mediator):Colleague(mediator){}
    void Send(string message)
    {
        m_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)
    {
        m_mediator->Send(message,this);
    }
    void Notify(string message)
    {
        cout << "同事2得到消息：" << message << endl;
    }
};
//ConcreteMediator 具体中介者
class ConcreteMediator:public Mediator
{
private:
    ConcreteColleague1 *m_colleague1;
    ConcreteColleague2 *m_colleague2;
public:
    void setColleague1(ConcreteColleague1 *colleague1)
    {
        this->m_colleague1=colleague1;
    }
    ConcreteColleague1 *getColleague1()
    {
        return m_colleague1;
    }
    void setColleague2(ConcreteColleague2 *colleague2)
    {
        this->m_colleague2=colleague2;
    }
    ConcreteColleague2 *getColleague2()
    {
        return m_colleague2;
    }
    void Send(string message,Colleague *colleague)
    {
        if(colleague==m_colleague1)
            m_colleague2->Notify(message);
        else
            m_colleague1->Notify(message);
    }
};
int main()
{
    ConcreteMediator *m=new ConcreteMediator();
    //让两个具体同时类认识中介对象
    ConcreteColleague1 *c1=new ConcreteColleague1(m);
    ConcreteColleague2 *c2=new ConcreteColleague2(m);
    //让中介者认识各个具体同事类对象
    m->setColleague1(c1);
    m->setColleague2(c2);
    //具体同事类对象的发送消息都通过中介者转发
    c1->Send("吃过饭了吗？");
    c2->Send("没有呢，你打算请客？");
    return 0;
}

由于有了Mediator，使得ConcreteColleague1和ConcreteColleague2在发送消息和接收消息时其实是通过中介者来完成的，这就减少了他们之间的耦合度。

下面看一个例子：

#include <iostream>

using namespace std;
class Country;
//联合国机构类，相当于Mediator类
class UnitedNations
{
public:
    virtual void Declare(string message,Country *colleague)=0;
};
//国家类，相当于Colleague类
class Country
{
protected:
    UnitedNations *m_mediator;
public:
    Country(UnitedNations *mediator)
    {
        this->m_mediator=mediator;
    }
};
//美国类，相当于ConcreteColleague1类
class USA:public Country
{
public:
    USA(UnitedNations *mediator):Country(mediator){}
    void Declare(string message)
    {
        m_mediator->Declare(message,this);
    }
    void GetMessage(string message)
    {
        cout << "美国获得对象消息：" << message << endl;
    }
};
//伊拉克类
class Iraq:public Country
{
public:
    Iraq(UnitedNations *mediator):Country(mediator){}
    void Declare(string message)
    {
        m_mediator->Declare(message,this);
    }
    void GetMessage(string message)
    {
        cout << "伊拉克获得对象消息：" << message << endl;
    }
};
//联合国安全理事会
class UnitedNationsSecurityCouncil:public UnitedNations
{
private:
    USA *m_colleague1;
    Iraq *m_colleague2;
public:
    void SetUSA(USA *colleague1)
    {
        this->m_colleague1=colleague1;
    }
    USA *GetUSA()
    {
        return m_colleague1;
    }
    void SetIraq(Iraq *colleague2)
    {
        this->m_colleague2=colleague2;
    }
    Iraq *GetIraq()
    {
        return m_colleague2;
    }
    void Declare(string message,Country *colleague)
    {
        if(colleague==m_colleague1)
            m_colleague2->GetMessage(message);
        else
            m_colleague1->GetMessage(message);
    }
};
int main()
{
    UnitedNationsSecurityCouncil *UNSC=new UnitedNationsSecurityCouncil();
    USA *c1=new USA(UNSC);
    Iraq *c2=new Iraq(UNSC);
    UNSC->SetUSA(c1);
    UNSC->SetIraq(c2);
    c1->Declare("不准研制核武器，否则要发动战争！");
    c2->Declare("我们没有核武器，也不怕侵略!");
    return 0;
}

　　中介者模式很容易在系统中应用，也很容易在系统中误用。当系统出现了“多对多”交互复杂的对象群时，不要急于使用中介模式，而要先反思你的系统在设计上是不是合理。

　　优点：Mediator的出现减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator；由于把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到他们之间的交互上来，也就是站在一个更宏观的角度看待系统。

　　缺点：由于ConcreteMediator控制了集中化，于是就把交互复杂性变为了中介者的复杂性，这就使得中介者会变得比任何一个ConcreteColleague都复杂。

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