设计模式-行为型模式-中介者模式

工程源码：

c++设计模式-行为型模式-中介者模式https://download.csdn.net/download/qq_40788199/85763979码云：

设计模式-行为型模式-中介者模式https://gitee.com/gongguixing/c-design-mode.git

1、模式的定义与特点

中介者（Mediator）模式的定义：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。

中介者模式是一种对象行为型模式，其主要优点如下。

1. 类之间各司其职，符合迪米特法则。
2. 降低了对象之间的耦合性，使得对象易于独立地被复用。
3. 将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

其主要缺点是：中介者模式将原本多个对象直接的相互依赖变成了中介者和多个同事类的依赖关系。当同事类越多时，中介者就会越臃肿，变得复杂且难以维护。

2、模式的结构与实现

中介者模式实现的关键是找出“中介者”，下面对它的结构和实现进行分析。

1. 模式的结构

中介者模式包含以下主要角色。

1. 抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
2. 具体中介者（Concrete Mediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
3. 抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
4. 具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

中介者模式的结构图如图 1 所示。

3、代码实现 

3.1、抽象中介者（Mediator）角色

#ifndef IMEDIATOR_H
#define IMEDIATOR_H

// 抽象中介者（Mediator）角色
// 它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。

class IColleague;

class IMediator
{
public:
    virtual ~IMediator() {}

    // 对象注册
    virtual void registryObject(IColleague *p)   = 0;

    // 转发
    virtual void relay(IColleague *p)   = 0;
};

#endif // IMEDIATOR_H

3.2、具体中介者（Concrete Mediator）角色

#ifndef CONCRETEMEDIATOR_H
#define CONCRETEMEDIATOR_H

#include "imediator.h"
#include <vector>
using namespace std;
// 具体中介者（Concrete Mediator）角色
// 实现中介者接口，定义一个 List 来管理同事对象，
// 协调各个同事角色之间的交互关系，因此它依赖于同事角色。

class ConcreteMediator : public IMediator
{
public:
    ConcreteMediator();

    // 对象注册
    void registryObject(IColleague *p)  override;

    // 转发
    void relay(IColleague *p) override;

private:
    vector<IColleague*> mPColleagues;
};

#endif // CONCRETEMEDIATOR_H

#include "concretemediator.h"
#include "icolleague.h"

ConcreteMediator::ConcreteMediator()
{

}

void ConcreteMediator::registryObject(IColleague *p)
{
    if (!p)
    {
        return;
    }

    vector<IColleague*>::iterator it = mPColleagues.begin();
    for (; it != mPColleagues.end(); it++)
    {
        // 对象已经存在不需要重复放入
        if (*it == p)
        {
            return;
        }
    }

    // 同事类将中介设置为当前
    p->setMedium(this);
    // 将同事类存入容器
    mPColleagues.push_back(p);
}

void ConcreteMediator::relay(IColleague *p)
{
    vector<IColleague*>::iterator it = mPColleagues.begin();
    for (; it != mPColleagues.end(); it++)
    {
        // 自己不用处理自己的消息
        if (*it == p)
        {
            continue;
        }

        (*it)->receive();
    }
}

 3.3、抽象同事类（Colleague）角色

#ifndef ICOLLEAGUE_H
#define ICOLLEAGUE_H

// 抽象同事类（Colleague）角色
// 定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，
// 实现所有相互影响的同事类的公共功能。

class IMediator;

class IColleague
{
public:
    virtual ~IColleague() {}

    // 设置中介对象
    virtual void setMedium(IMediator *p) = 0;

    virtual void receive() = 0;

    virtual void send() = 0;
};

#endif // ICOLLEAGUE_H

3.4、具体同事类（Concrete Colleague）角色 A

#ifndef CONCRETECOLLEAGUEA_H
#define CONCRETECOLLEAGUEA_H

#include "icolleague.h"
#include "imediator.h"

// 具体同事类（Concrete Colleague）角色
// 是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

class ConcreteColleagueA : public IColleague
{
public:
    ConcreteColleagueA();

    void setMedium(IMediator *p) override;

    void receive() override;

    void send() override;

private:
    IMediator *mPMediator;
};

#endif // CONCRETECOLLEAGUEA_H

#include "concretecolleaguea.h"
#include <iostream>

ConcreteColleagueA::ConcreteColleagueA()
{
    mPMediator = nullptr;
}

void ConcreteColleagueA::setMedium(IMediator *p)
{
    mPMediator = p;
}

void ConcreteColleagueA::receive()
{
    std::cout << "ConcreteColleagueA receive request." << std::endl;
}

void ConcreteColleagueA::send()
{
    std::cout << "ConcreteColleagueA send request." << std::endl;
    // 中介转发请求
    if (mPMediator)
    {
        mPMediator->relay(this);
    }
}

 3.5、具体同事类（Concrete Colleague）角色

#ifndef CONCRETECOLLEAGUEB_H
#define CONCRETECOLLEAGUEB_H

#include "icolleague.h"
#include "imediator.h"

// 具体同事类（Concrete Colleague）角色
// 是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

class ConcreteColleagueB : public IColleague
{
public:
    ConcreteColleagueB();

    void setMedium(IMediator *p) override;

    void receive() override;

    void send() override;

private:
    IMediator *mPMediator;
};

#endif // CONCRETECOLLEAGUEB_H

#include "concretecolleagueb.h"
#include <iostream>

ConcreteColleagueB::ConcreteColleagueB()
{
    mPMediator = nullptr;
}

void ConcreteColleagueB::setMedium(IMediator *p)
{
    mPMediator = p;
}

void ConcreteColleagueB::receive()
{
    std::cout << "ConcreteColleagueB receive request." << std::endl;
}

void ConcreteColleagueB::send()
{
    std::cout << "ConcreteColleagueB send request." << std::endl;
    // 中介转发请求
    if (mPMediator)
    {
        mPMediator->relay(this);
    }
}

3.6、具体中介者（Concrete Mediator）角色

#ifndef CONCRETEMEDIATOR_H
#define CONCRETEMEDIATOR_H

#include "imediator.h"
#include <vector>
using namespace std;
// 具体中介者（Concrete Mediator）角色
// 实现中介者接口，定义一个 List 来管理同事对象，
// 协调各个同事角色之间的交互关系，因此它依赖于同事角色。

class ConcreteMediator : public IMediator
{
public:
    ConcreteMediator();

    // 对象注册
    void registryObject(IColleague *p)  override;

    // 转发
    void relay(IColleague *p) override;

private:
    vector<IColleague*> mPColleagues;
};

#endif // CONCRETEMEDIATOR_H

#include "concretecolleaguec.h"
#include <iostream>

ConcreteColleagueC::ConcreteColleagueC()
{
    mPMediator = nullptr;
}

void ConcreteColleagueC::setMedium(IMediator *p)
{
    mPMediator = p;
}

void ConcreteColleagueC::receive()
{
    std::cout << "ConcreteColleagueC receive request." << std::endl;
}

void ConcreteColleagueC::send()
{
    std::cout << "ConcreteColleagueC send request." << std::endl;
    // 中介转发请求
    if (mPMediator)
    {
        mPMediator->relay(this);
    }
}

 3.7、调用示例

#include <iostream>
#include "concretemediator.h"
#include "concretecolleaguea.h"
#include "concretecolleagueb.h"
#include "concretecolleaguec.h"

int main()
{

    // 中介者（Mediator）模式的定义：
    // 定义一个中介对象来封装一系列对象之间的交互，
    // 使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。
    // 中介者模式又叫调停模式，它是迪米特法则的典型应用。

    // 实例化中介
    IMediator * pMed = new ConcreteMediator();
    // 实例化同事
    IColleague * pCOlA = new ConcreteColleagueA();
    IColleague * pCOlB = new ConcreteColleagueB();
    IColleague * pCOlC = new ConcreteColleagueC();

    // 注册通行对象
    pMed->registryObject(pCOlA);
    pMed->registryObject(pCOlB);
    pMed->registryObject(pCOlC);

    // A发送消息
    pCOlA->send();

    std::cout << "-------------------------------------" << std::endl;

    // B发送消息
    pCOlB->send();

    std::cout << "-------------------------------------" << std::endl;

    // C发送消息
    pCOlC->send();

    return 0;
}

 

模式的应用场景

前面分析了中介者模式的结构与特点，下面分析其以下应用场景。

• 当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。
• 当想创建一个运行于多个类之间的对象，又不想生成新的子类时。