设计模式------中介者模式(Mediator Pattern)-优快云博客

本文链接：https://blog.youkuaiyun.com/joyney/article/details/4054361

设计模式------中介者模式(Mediator Pattern)

一、引子

中介在现实生活中并不陌生，满大街的房屋中介、良莠不齐的出国中介……。它们的存在是因为它们能给我们的生活带来一些便利：租房、买房用不着各个小区里瞎转；出国留学也不用不知所措。

中介者模式在程序设计中也起到了类似的作用。

二、定义与结构

GOF给中介者模式下的定义是：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。简单点来说，将原来两个直接引用或者依赖的对象拆开，在中间加入一个“中介”对象，使得两头的对象分别和“中介”对象引用或者依赖。

当然并不是所有的对象都需要加入“中介”对象。如果对象之间的关系原本一目了然，中介对象的加入便是“画蛇添足”。

来看下中介者模式的组成部分吧。

1) 抽象中介者（Mediator）角色：抽象中介者角色定义统一的接口用于各同事角色之间的通信。

2) 具体中介者（Concrete Mediator）角色：具体中介者角色通过协调各同事角色实现协作行为。为此它要知道并引用各个同事角色。

3) 同事（Colleague）角色：每一个同事角色都知道对应的具体中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作。

来自《设计模式》一书的类图：

由于中介者的行为与要使用的数据与具体业务紧密相关，抽象中介者角色提供一个能方便很多对象使用的接口是不太现实的。所以抽象中介者角色往往是不存在的，或者只是一个标示接口。如果有幸能够提炼出真正带有行为的抽象中介者角色，我想同事角色对具体中介者角色的选择也是策略的一种应用。

“恰到好处，过犹不及”。适合自己系统的便是最好的。

三、进一步讨论

是否还记得应用广泛的MVC分为哪三层？模型层（Model）、表现层（View）还有控制层（Control/Mediator）。控制层便是位于表现层与模型层之间的中介者。笼统地说MVC也算是中介者模式在框架设计中的一个应用。

由于中介者模式在定义上比较松散，在结构上和观察者模式、命令模式十分相像；而应用目的又与结构模式“门面模式”有些相似。

在结构上，中介者模式与观察者模式、命令模式都添加了中间对象——只是中介者去掉了后两者在行为上的方向。因此中介者的应用可以仿照后两者的例子去写。但是观察者模式、命令模式中的观察者、命令都是被客户所知的，具体哪个观察者、命令的应用都是由客户来指定的；而大多中介者角色对于客户程序却是透明的。当然造成这种区别的原因是由于它们要达到的目的不同。

从目的上看，中介者模式与观察者模式、命令模式便没有了任何关系，倒是与前面讲过的门面模式有些相似。

但是门面模式是介于客户程序与子系统之间的，而中介者模式是介于子系统与子系统之间的。这也注定了它们有很大的区别：门面模式是将原有的复杂逻辑提取到一个统一的接口，简化客户对逻辑的使用。它是被客户所感知的，而原有的复杂逻辑则被隐藏了起来。而中介者模式的加入并没有改变客户原有的使用习惯，它是隐藏在原有逻辑后面的，使得代码逻辑更加清晰可用。

前面已经陆陆续续的将中介者模式的特点写了出来。这里再总结一下。使用中介者模式最大的好处就是将同事角色解耦。这带来了一系列的系统结构改善：提高了原有系统的可读性、简化原有系统的通信协议——将原有的多对多变为一对多、提高了代码的可复用性……

但是中介者角色集中了太多的责任，所有有关的同事对象都要由它来控制。这不由得让我想起了简单工厂模式，但是由于中介者模式的特殊性——与业务逻辑密切相关，不能采用类似工厂方法模式的解决方法。因此建议在使用中介者模式的时候注意控制中介者角色的大小。

讨论了这么多关于中介者模式的特点。可以总结出中介者模式的使用时机：一组对象以定义良好但是复杂的方式进行通信，产生了混乱的依赖关系，也导致对象难以复用。

四、总结

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

中介者模式（Mediator）定义一个对象封装一系列多个对象如何相互作用，使得对象间不需要显式地相互引用，从而使其耦合更加松散，并且还让我们可以独立变化多个对象相互作用。结构图如下：

以一个聊天室的例子进行说明，一个聊天室可以很多成员，成员可以加入不同的讨论组，聊天室就是一个中介，讨论组中的成员通过聊天室发送消息。结构图如下：

实现代码：

// IChatroom.h
class User;
class IChatroom
{
public :
    IChatroom();
     virtual ~ IChatroom();

     virtual void Register(User * ) = 0 ;
     virtual void Send( char * pFrom, char * pTo, char * pMsg) = 0 ;
};

// IChatroom.cpp
#include " stdafx.h "
#include " IChatroom.h "

IChatroom::IChatroom()
{

}

IChatroom:: ~ IChatroom()
{

}

// Chatroom.h
#include " IChatroom.h "
#include < map >

using namespace std;

class Chatroom : public IChatroom
{
public :
    Chatroom();
     virtual ~ Chatroom();

     void Register(User * );
     void Send( char * pFrom, char * pTo, char * pMsg);
private :
    map < char * , User *> m_mapUsers;
};

// Chatroom.cpp
#include " stdafx.h "
#include " Chatroom.h "
#include " User.h "

Chatroom::Chatroom()
{

}

Chatroom:: ~ Chatroom()
{

}

void Chatroom::Register(User * pUser)
{
     char * a = pUser -> m_pName;
     if (m_mapUsers[pUser -> m_pName] == NULL)
    {
        m_mapUsers[pUser -> m_pName] = pUser;
    }

    pUser -> SetChatroom( this );
}

void Chatroom::Send( char * pFrom, char * pTo, char * pMsg)
{
    User * pUserTo = (User * )m_mapUsers[pTo];
     if (pUserTo != NULL)
    {
        pUserTo -> Receive(pFrom, pMsg);
    }
}

// User.h
class Chatroom;
class User
{
public :
    User( char * );
     virtual ~ User();

     void Send( char * pTo, char * pMsg);
     virtual void Receive( char * pFrom, char * pMsg);
     void SetChatroom(Chatroom * );
    friend class Chatroom;
private :
     char * m_pName;
    Chatroom * m_pChatroom;
};

// User.cpp
#include " stdafx.h "
#include " User.h "
#include " Chatroom.h "
#include < iostream >

using namespace std;

User::User( char * pName)
{
    m_pName = pName;
}

User:: ~ User()
{
     if (m_pChatroom != NULL)
    {
        delete m_pChatroom;
        m_pChatroom = NULL;
    }
}

void User::Send( char * pTo, char * pMsg)
{
    m_pChatroom -> Send(m_pName, pTo, pMsg);
}

void User::SetChatroom(Chatroom * pChatroom)
{
    m_pChatroom = pChatroom;
}

void User::Receive( char * pFrom, char * pMsg)
{
    cout << pFrom << " to " << this -> m_pName << " : " << pMsg << endl;
}

// UserInGroupA.h
#include " User.h "

class UserInGroupA : public User
{
public :
    UserInGroupA( char * );
     virtual ~ UserInGroupA();

     virtual void Receive( char * pFrom, char * pMsg);
};

// UserInGroupA.cpp
#include " stdafx.h "
#include " UserInGroupA.h "
#include < iostream >

using namespace std;

UserInGroupA::UserInGroupA( char * pName) : User(pName)
{

}

UserInGroupA:: ~ UserInGroupA()
{

}

void UserInGroupA::Receive( char * pFrom, char * pMsg)
{
    cout << " 组A成员收到消息- " ;
    User::Receive(pFrom, pMsg);
}

// UserInGroupB.h
#include " User.h "

class UserInGroupB : public User
{
public :
    UserInGroupB( char * );
     virtual ~ UserInGroupB();

     virtual void Receive( char * pFrom, char * pMsg);
};

// UserInGroupB.cpp
#include " stdafx.h "
#include " UserInGroupB.h "
#include < iostream >

using namespace std;

UserInGroupB::UserInGroupB( char * pName) : User(pName)
{

}

UserInGroupB:: ~ UserInGroupB()
{

}

void UserInGroupB::Receive( char * pFrom, char * pMsg)
{
    cout << " 组B成员收到消息- " ;
    User::Receive(pFrom, pMsg);
}

// main.cpp
#include " stdafx.h "
#include " Chatroom.h "
#include " UserInGroupA.h "
#include " UserInGroupB.h "

int main( int argc, char * argv[])
{
    Chatroom * pChatroom = new Chatroom;
    User * pUserA = new UserInGroupA( " UserA " );
    User * pUserB = new UserInGroupA( " UserB " );
    User * pUserC = new UserInGroupB( " UserC " );

    pChatroom -> Register(pUserA);
    pChatroom -> Register(pUserB);
    pChatroom -> Register(pUserC);

    pUserA -> Send( " UserB " , " 你好，UserB " );
    pUserB -> Send( " UserC " , " 你好，UserC " );
    pUserC -> Send( " UserA " , " 你好，UserA " );

     return 0 ;
}