中介者模式

中介者模式定义

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

中介者模式结构图

中介者模式结构图如下所示：

图 01 中介者模式结构图

中介者模式套用代码

#include "iostream"
using namespace std;
#include <string>

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

class Colleague
{
protected:
    Mediator* mediator;
public:
    Colleague(Mediator* mediator)
    {
        this->mediator = mediator;
    }
};

// 同事1
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;
    }
};

// 同事2
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;
    }
};

// 具体中介者类
class ConcreteMediator : public Mediator
{
private:
    ConcreteColleague1* colleague1;
    ConcreteColleague2* colleague2;
public:
    void SetConcreteColleague1(ConcreteColleague1* colleague1)
    {
        this->colleague1 = colleague1;
    }

    void SetConcreteColleague2(ConcreteColleague2* colleague2)
    {
        this->colleague2 = colleague2;
    }

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

void main()
{
    ConcreteMediator* m = new ConcreteMediator();

    ConcreteColleague1* c1 = new ConcreteColleague1(m);
    ConcreteColleague2* c2 = new ConcreteColleague2(m);

    m->SetConcreteColleague1(c1);
    m->SetConcreteColleague2(c2);

    c1->Send("听过饭了吗？");
    c2->Send("没有呢，你打算请客？");

    delete m;
    m = NULL;
    delete c1;
    c1 = NULL;
    delete c2;
    c2 = NULL;
}

中介者模式特点

① 尽管一个系统分割成许多对象通常可以增加其可用性,但是对象间相互连接的激增又会降低其可复用性了，因为大量的连接使得一个对象不可能在没有其他对象的支持下工作，系统表现为一个不可分割的整体，所以，对系统的行为进行任何较大的改动就十分困难了。

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

③ Mediator的出现减少了各个Colleague的后河，使得可以独立地改变和复用各个Colleague类和Mediator类，比如任何国家的改变不会影响到其他国家，而只是与安理会发生变化。其次，由于把对象如何协调进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到他们之间的交互上来，也就是站在一个更宏观的角度去看待系统。

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

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

中介者模式实例应用

中介者模式实例应用类图

图 02 中介者模式实例应用类图

中介者模式实例应用代码

#include "iostream"
using namespace std;
#include <string>

class CCountry;
// 联合国机构接口
class CUnitedNations
{
public:
    virtual void Declare(string message, CCountry* colleague) = 0;
};

// 国家接口
class CCountry
{
protected:
    CUnitedNations* mediator;
public:
    CCountry(CUnitedNations* mediator)
    {
        this->mediator = mediator;
    }
};

class CUSA : public CCountry
{
public:
    CUSA(CUnitedNations* mediator)
        : CCountry(mediator)
    {

    }

    void Declare(string message)
    {
        this->mediator->Declare(message, this);
    }

    void GetMessage(string message)
    {
        cout << "美国获对方信息:" << message << endl;
    }
};

// 伊拉克
class CIraq : public CCountry
{
public:
    CIraq(CUnitedNations* mediator)
        : CCountry(mediator)
    {

    }
    
    void Declare(string message)
    {
        this->mediator->Declare(message, this);
    }

    void GetMessage(string message)
    {
        cout << "伊拉克获对方信息:" << message << endl;
    }
};

// 联合国安全理事会
class CUniteNationSecurityCouncil : public CUnitedNations
{
private:
    CUSA* colleague1;
    CIraq* colleague2;
public:
    // 获得CUSA类对象
    void SetCUSAColleague(CUSA* colleague1)
    {
        this->colleague1 = colleague1;
    }

    // 获得CIraq类对象
    void SetCIraqColleague(CIraq* colleague2)
    {
        this->colleague2 = colleague2;
    }

    virtual void Declare(string message, CCountry* colleague)
    {
        if(colleague == colleague1)
        {
            colleague2->GetMessage(message);
        }
        else
        {
            colleague1->GetMessage(message);
        }
    }
};

void main()
{
    CUniteNationSecurityCouncil* UNSC = new CUniteNationSecurityCouncil();

    CUSA* usa = new CUSA(UNSC);
    CIraq* iraq = new CIraq(UNSC);

    UNSC->SetCUSAColleague(usa);
    UNSC->SetCIraqColleague(iraq);

    usa->Declare("不准研制核武器，否则要发动战争");
    iraq->Declare("我们没有核武器，也不怕侵略");

    delete UNSC;
    UNSC = NULL;
    delete usa;
    usa = NULL;
    delete iraq;
    iraq = NULL;
}

2014-12-07   21:54:25