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

问题

在面向对象系统的设计和开发过程中，对象间的交互和通信时最为常见的情况，因为对象间的交互本身就是一种通信。在系统比较小的时候，可能对象间的通信不是很多，对象也比较少，我们可以直接硬编码到各个对象的方法中。但是当系统规模变大，对象的量变引起系统复杂度的急剧增加，对象间的通信业变得越来越复杂，这时我们就要提供一个专门处理对象间交互和通信的类，这个中介者就是Mediator模式。Mediator模式提供将对象间的交互和通讯封装在一个类中，各个对象间的通信不必显示去声明和引用，大大降低了系统的复杂性能(了解一个对象总比深入熟悉n个对象要好)。另外Mediator模式还带来了系统对象间的松耦合。

中介者模式

中介者模式：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而降低耦合，而且可以独立地改变它们之间的交互

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

小demo

mediator.h

#pragma once
#include <string>
#include <iostream>
using namespace std;
class Colleague;
//抽象中介者类，定义了同事对象到中介者对象的接口
class Mediator
{
public:
    virtual void Send(string msg,Colleague* col)=0;
};
//抽象同事类
class Colleague
{
protected:
    Mediator* mediator;
public:
    Colleague(Mediator* temp)
    {
        mediator=temp;
    }
};
//同事A，
//每个具体同事只知道自己的行为，而不了解其他同事类的情况，但它们却都认识中介者对象
class ColleagueA : public Colleague
{
public:
    ColleagueA(Mediator* temp) : Colleague(temp){}
    void Send(string strMsg)
    {
        mediator->Send(strMsg,this);
    }
    void Notify(string strMsg)
    {
        cout<<"同事A获得了消息："<<strMsg<<endl;
    }
};
//同事B
class ColleagueB : public Colleague
{
public:
    ColleagueB(Mediator* temp) : Colleague(temp){}
    void Send(string strMsg)
    {
        mediator->Send(strMsg,this);
    }
    void Notify(string strMsg)
    {
        cout<<"同事B获得了消息："<<strMsg<<endl;
    }
};

//具体中介者类，实现抽象类的方法
//它需要自导所有具体同事类，并从具体同事接收消息，向具体同事对象发出命令
class ConcreteMediator : public Mediator
{
private:
    ColleagueA* colA;
    ColleagueB* colB;
public:
    void InitColleage(ColleagueA* tempA,ColleagueB* tempB)
    {
        colA=tempA;
        colB=tempB;
    }
    virtual void Send(string msg,Colleague* col)
    {
        if (col==colA)
        {
            colB->Notify(msg);
        }
        else
        {
            colA->Notify(msg);
        }
    }
};

main.cpp 

#include "Mediator.h"
#include <windows.h>
int main()
{
    ConcreteMediator* mediator=new ConcreteMediator();
    //让同事认识中介者
    ColleagueA* colA=new ColleagueA(mediator);
    ColleagueB* colB=new ColleagueB(mediator);
    //让中介者认识具体的同事
    mediator->InitColleage(colA,colB);
    
    colA->Send("吃饭了吗？");
    colB->Send("还没吃，你请吗？");
    system("pause");
    return 0;
}

注意到，两个Colleague对象并不知道他交互的对象，并且也不是显示地处理交互过程，这一切都是通过Mediator对象来完成的。

Mediator模式还有一个很显著特点就是将控制集中，集中的优点就是便于管理，也正式符号了OO设计中的每个类的职责要单一和集中的原则。

中介者持有所有同事引用，然后在里面做一些逻辑操作，然后每个同事类持有中介者引用，依次完成交互。

中介者模式介绍

• 何时使用：多个类相互耦合，形成了网状结构。对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。中介者模式可以处理不同类之间的通信，支持松耦合，用来降低多个对象和类之间的通信复杂性使代码易于维护：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
• 如何解决：将上述网状结构分离为星型结构，将对象之间的通信封装到一个中介类中单独处理。
• 优点： 1、降低了类的复杂度，将多对多转化成了一对多。 2、各个类之间的解耦。 3、符合迪米特原则。
• 缺点：中介者会庞大，变得复杂难以维护。
• 使用场景： 1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象。 2、想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。3、聊天室模型
• 应用实例： 1、中国加入 WTO 之前是各个国家相互贸易，结构复杂，现在是各个国家通过 WTO 来互相贸易。 2、机场调度系统。 3、MVC 框架，其中C（控制器）就是 M（模型）和 V（视图）的中介者。

与其他设计模式关系

外观模式：结构型，对子系统提供统一的接口，单向，所有请求都委托子系统完成，树型
代理模式：结构型，引用代理对象的方式来访问目标对象，单向
中介者模式：行为型，用一个中介对象来封装一系列同事对象的交互行为，双向，一对多星型

责任链模式、 命令模式、 中介者模式和观察者模式用于处理请求发送者和接收者之间的不同连接方式：

• 责任链按照顺序将请求动态传递给一系列的潜在接收者， 直至其中一名接收者对请求进行处理。
• 命令在发送者和请求者之间建立单向连接。
• 中介者清除了发送者和请求者之间的直接连接， 强制它们通过一个中介对象进行间接沟通。
• 观察者允许接收者动态地订阅或取消接收请求。

外观模式和中介者的职责类似： 它们都尝试在大量紧密耦合的类中组织起合作。

• 外观为子系统中的所有对象定义了一个简单接口，但是它不提供任何新功能。子系统本身不会意识到外观的存在。子系统中的对象可以直接进行交流。
• 中介者将系统中组件的沟通行为中心化。各组件只知道中介者对象， 无法直接相互交流。

中介者和观察者之间的区别往往很难记住。 在大部分情况下， 你可以使用其中一种模式， 而有时可以同时使用。

• 中介者的主要目标是消除一系列系统组件之间的相互依赖(双向引用)。 这些组件将依赖于同一个中介者对象。
• 观察者的目标是在对象之间建立动态的单向连接， 使得部分对象可作为其他对象的附属发挥作用。