中介者模式

1.动机

在用户与用户直接聊天的设计方案中，用户对象之间存在很强的关联性，将导致系统出现如下问题：

• 系统结构复杂：对象之间存在大量的相互关联和调用，若有一个对象发生变化，则需要跟踪和该对象关联的其他所有对象，并进行适当处理。
• 对象可重用性差：由于一个对象和其他对象具有很强的关联，若没有其他对象的支持，一个对象很难被另一个系统或模块重用，这些对象表现出来更像一个不可分割的整体，职责较为混乱。
• 系统扩展性低：增加一个新的对象需要在原有相关对象上增加引用，增加新的引用关系也需要调整原有对象，系统耦合度很高，对象操作很不灵活，扩展性差。
• 在面向对象的软件设计与开发过程中，根据“单一职责原则”，我们应该尽量将对象细化，使其只负责或呈现单一的职责。
• 对于一个模块，可能由很多对象构成，而且这些对象之间可能存在相互的引用，为了减少对象两两之间复杂的引用关系，使之成为一个松耦合的系统，我们需要使用中介者模式。

2.定义

• 中介者模式(Mediator Pattern)定义：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。
• 面向对象设计鼓励将行为分布到各个对象中。但是，这种分布可能会导致对象间有许多连接。在最坏的情况下，每一个对象都知道其他所有对象，就造成了复杂的关联关系。虽然将一个系统分割成许多对象通常可以增强可复用性，但是对象间相互连接的激增又会降低其可复用性。大量的相互连接使得一个对象似乎不太可能在没有其他对象的支持下工作，这样使得系统表现为一个不可分割的整体。而且，对系统的行为进行任何较大的改动都十分困难，因为行为被分布在许多对象中。结果是，你可能不得不定义很多子类以定制系统的行为。

在联合国还没有成立时，国与国之间的关系是这样的：

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

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

3.结构

• Mediator：中介者，它定义了一个接口用于与各个Colleague对象通信；
• ConcreteMediator：具体的中介者，它通过协调各Colleague对象实现协作行为；并了解和维护它的各个Colleague；
• Colleague：同事类，每一个同事类都知道它的中介者对象；每一个同事对象在需要与其他的同事通信的时候，而是与它的中介者通信。

同事向一个中介者对象发送和接收请求。中介者在各同事间适当地转发请求以实现协作行为。

4.代码分析

#include <iostream>
#include <string>
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(string message, Colleague *rec) ;
    virtual void NotifySend(string message) = 0;
    virtual void Notifyrec(string message) = 0;

protected:
    Mediator *m_pMediator;
};

//具体抽象类
class ConcreteColleague1 : public Colleague
{
public:
    ConcreteColleague1(Mediator *pMediator) : Colleague(pMediator){}

    void NotifySend(string message)
    {
        cout << "The message of cc1 is send to mediator: " << message<< endl;
    }

    void Notifyrec(string message)
    {
        cout << "The message of cc1 is rec from mediator: " << message <<endl;
    }
    
};

//具体抽象类
class ConcreteColleague2 : public Colleague
{
public:
    ConcreteColleague2(Mediator *pMediator) : Colleague(pMediator){}

    void NotifySend(string message)
    {
        cout << "The message of cc2 is send to mediator: " << message<< endl;
    }

    void Notifyrec(string message)
    {
        cout << "The message of cc2 is rec from mediator: " << message << endl;
    }
};

//抽象中介者
class Mediator
{
public:
    virtual void Sent(string message, Colleague *pColleague, Colleague * pTo) = 0;
};

//具体中介者
class ConcreteMediator : public Mediator
{
public:
    // The mediator forward the message
    void Sent(string message, Colleague* pFrom, Colleague* pTo)
    {
        to = pFrom;
        from = pTo;

        //从真正的发送者获取信息
        to->NotifySend(message);
        //从中介传到真正的接收者
        from->Notifyrec(message);
    }

private:
    // The Mediator knows all the Colleague
    Colleague *to;
    Colleague *from;
};

//
void Colleague::Send(string message, Colleague *rec)
{
    //在函数中采用多态
    m_pMediator->Sent(message, this, rec);
}


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

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

    pColleague1->Send("qiuyu", pColleague2);
    cout << "----------------------------------------" << endl;
    pColleague2->Send("wangyue", pColleague1);

    system("pause");
    return 0;
}

5.模式分析

中介者模式可以使对象之间的关系数量急剧减少。

中介者承担两方面的职责：

• 中转作用（结构性）：通过中介者提供的中转作用，各个同事对象就不再需要显式引用其他同事，当需要和其他同事进行通信时，通过中介者即可。该中转作用属于中介者在结构上的支持。
• 协调作用（行为性）：中介者可以更进一步的对同事之间的关系进行封装，同事可以一致地和中介者进行交互，而不需要指明中介者需要具体怎么做，中介者根据封装在自身内部的协调逻辑，对同事的请求进行进一步处理，将同事成员之间的关系行为进行分离和封装。该协调作用属于中介者在行为上的支持。

6.优点

• 减少了子类生成，Mediator将原本分布于多个对象间的行为集中在一起。改变这些行为只需生成Meditator的子类即可。这样各个Colleague类可被重用；
• 它将各Colleague解耦，Mediator有利于各Colleague间的松耦合。你可以独立的改变和复用各Colleague类和Mediator类；
• 它简化了对象协议，用Mediator和Colleague间的一对多的交互来代替多对多的交互。一对多的关系更容易理解、维护和扩展；
• 它对对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，使你将注意力从对象各自本身的行为转移到它们之间的交互上来。这有助于弄清楚一个系统中的对象是如何交互的；

7.缺点

• 它使控制集中化，中介者模式将交互的复杂性变为中介者的复杂性。因为中介者封装了协议，它可能变得比任一个Colleague都复杂。这可能使得中介者自身成为一个难于维护的庞然大物。

8.适用场景

• 系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。
• 一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。
• 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。可以通过引入中介者类来实现，在中介者中定义对象。
• 交互的公共行为，如果需要改变行为则可以增加新的中介者类。

9.和外观模式的区别

• 外观模式与中介者模式的不同之处在于它是对一个对象子系统进行抽象，从而提供了一个更为方便的接口；
• 外观模式的协议是单向的，即外观模式向子系统提出请求，但反过来则不行；
• 中介者模式，是进行多个对象之间的协作，通信是多向的。