[设计模式] 17 中介者模式 Mediator Pattern

在GOF的《设计模式:可复用面向对象软件的基础》一书中对中介者模式是这样说的：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

我们都知道，面向对象设计鼓励将行为分布到各个对象中。但是，这种分布可能会导致对象间有许多连接。在最坏的情况下，每一个对象都知道其他所有对象，就造成了复杂的关联关系。虽然将一个系统分割成许多对象通常可以增强可复用性，但是对象间相互连接的激增又会降低其可复用性。大量的相互连接使得一个对象似乎不太可能在没有其他对象的支持下工作，这样使得系统表现为一个不可分割的整体。而且，对系统的行为进行任何较大的改动都十分困难，因为行为被分布在许多对象中。结果是，你可能不得不定义很多子类以定制系统的行为。

问题再回到联合国的问题上来，在联合国还没有成立时，国与国之间的关系是这样的：

当联合国成立以后，国与国之间出现纠纷时，是这样的：

联合国的成立，让很多关系简单化了，让问题的处理也简单化了，使国与国之间因为纠纷产生摩擦的几率减小了，让世界更和平了。

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

类图和实例

Mediator类：抽象中介者，定义了同事对象交互的接口。

ConcreteMediator类：具体中介者对象，实现抽象类中的方法，此具体中介者对象需要知道所有具体同事类，并从具体同事接受消息，向具体同事对象发送命令。

Colleague类：抽象同事类。

ConcreteColleague类：具体同事类，实现抽象同事类中的方法。每一个同时类需要知道中介者对象；每个具体同事类只需要了解自己的行为，而不需要了解其他同事类的情况。

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

using namespace std;

class Colleage
{
private:
    string name;
    string content;
public:
    Colleage(string n = " "):name(n){};
    void set_name(string name)
    {
        this->name = name;
    }
    string get_name()
    {
        return this->name;
    }
    void set_content(string content)
    {
        this->content = content;
    }
    string get_content()
    {
        if(content.size() != 0)
            return content;
        else return "Copy that";
    }
    virtual void talk(){};

};

class Monitor : public Colleage
{
public:
    Monitor(string n = ""):Colleage(n){};
    virtual void talk()
    {
        cout<<"班长 "<<get_name()<<" 说："<<get_content()<<endl;
    }
};

class Secretary : public Colleage
{
public:
    Secretary(string n = ""):Colleage(n){};
    virtual void talk()
    {
        cout<<"团支书 "<<get_name()<<" 说："<<get_content()<<endl;
    }
};

class StudentA : public Colleage
{
public:
    StudentA(string n = ""):Colleage(n){};
    virtual void talk()
    {
        cout<<"学生 A "<<get_name()<<" 说："<<get_content()<<endl;
    }
};

class StudentB : public Colleage
{
public:
    StudentB(string n = ""):Colleage(n){};
    virtual void talk()
    {
        cout<<"学生 B "<<get_name()<<" 说："<<get_content()<<endl;
    }
};

class Mediator
{
public:
    vector<Colleage*> studentList;
    virtual void add_student(Colleage *student)
    {
        studentList.push_back(student);
    };
    virtual void notify(Colleage *student){};    
};

class QQMediator : public Mediator
{
public:
    virtual void notify(Colleage *student)
    {
        student->talk();
        for(int i = 0 ; i < studentList.size() ; ++i)
        {            
            if(student != studentList[i])
            {
                studentList[i]->talk();
            }
        }
    };    
};


int main()
{
    QQMediator qq;
    Monitor *studentMonitor = new Monitor("Foxx");
    Secretary *studentSecretary = new Secretary("TC");
    StudentA *studentA = new StudentA("Jack");
    StudentB *studentB = new StudentB("Frank");        

    qq.add_student(studentSecretary);
    qq.add_student(studentA);
    qq.add_student(studentB);     

    studentMonitor->set_content("明天开始放假！");
    qq.notify(studentMonitor);   
    return 0;
}

 

#include <iostream>
using namespace std;

#define SAFE_DELETE(p) if (p) { delete p; p = NULL; }

class Mediator;

class Colleague
{
public:
     Colleague(Mediator *pMediator) : m_pMediator(pMediator){}

     virtual void Send(wchar_t *message) = 0;

protected:
     Mediator *m_pMediator;
};

class ConcreteColleague1 : public Colleague
{
public:
     ConcreteColleague1(Mediator *pMediator) : Colleague(pMediator){}

     void Send(wchar_t *message);

     void Notify(wchar_t *message)
     {
          wcout<<message<<endl;
     }
};

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

     void Send(wchar_t *message);

     void Notify(wchar_t *message)
     {
          cout<<"ConcreteColleague2 is handling the message."<<endl;
          wcout<<message<<endl;
     }
};

class Mediator
{
public:
     virtual void Sent(wchar_t *message, Colleague *pColleague) = 0;
};

class ConcreteMediator : public Mediator
{
public:
     // The mediator forward the message
     void Sent(wchar_t *message, Colleague *pColleague)
     {
          ConcreteColleague1 *pConcreteColleague1 = dynamic_cast<ConcreteColleague1 *>(pColleague);
          if (pConcreteColleague1)
          {
               cout<<"The message is from ConcreteColleague1. Now mediator forward it to ConcreteColleague2"<<endl;
               if (m_pColleague2)
               {
                    m_pColleague2->Notify(message);
               }
          }
          else
          {
               if (m_pColleague1)
               {
                    m_pColleague1->Notify(message);
               }
          }
     }

     void SetColleague1(Colleague *pColleague)
     {
          m_pColleague1 = dynamic_cast<ConcreteColleague1 *>(pColleague);
     }

     void SetColleague2(Colleague *pColleague)
     {
          m_pColleague2 = dynamic_cast<ConcreteColleague2 *>(pColleague);
     }

private:
     // The Mediator knows all the Colleague
     ConcreteColleague1 *m_pColleague1;
     ConcreteColleague2 *m_pColleague2;
};

void ConcreteColleague1::Send(wchar_t *message)
{
     // The second parameter mark where the message comes from
     m_pMediator->Sent(message, this);
}

void ConcreteColleague2::Send(wchar_t *message)
{
     m_pMediator->Sent(message, this);
}

int main()
{
     // Create the mediator
     Mediator *pMediator = new ConcreteMediator();

     Colleague *pColleague1 = new ConcreteColleague1(pMediator);
     Colleague *pColleague2 = new ConcreteColleague2(pMediator);

     ConcreteMediator *pConcreteMediator = dynamic_cast<ConcreteMediator *>(pMediator);
     pConcreteMediator->SetColleague1(pColleague1);
     pConcreteMediator->SetColleague2(pColleague2);

     wchar_t message[260] = L"Where are you from?";
     pColleague1->Send(message);

     return 0;
}

 

适用性：

1.一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。

2.一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象。

3.想定制一个分布在多个类中的行为，而又不想生成太多的子类。

优缺点：

使用中介者模式的优点：

  1.降低了系统对象之间的耦合性，使得对象易于独立的被复用。

  2.提高系统的灵活性，使得系统易于扩展和维护。

使用中介者模式的缺点：

  由于我们这个“中介“承担了较多的责任，所以一旦这个中介对象出现了问题，那么整个系统就会受到重大的影响。