中介者模式（Mediator）

设计模式系列

Mediator 中介者模式——对象行为模式

1.意图

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

 

2.适用性

• 一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
• 一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象
• 想定制一个分布在多个类中的行为，而又不想生成太多的子类

 

3.结构

 

 

4.参与者

• Mediator

—— 中介者定义一个接口用于各同事（Colleague）对象通信

• ConcreteMediator

—— 具体中介者通过协调各同事对象实现协作行为

—— 了解并维护它的各个同事

• Colleague class(同事类)

—— 每一个同事类都知道它的中介者对象

—— 每一个同事对象在需与其他的同事通信的时候，与它的中介者通信

 

5.协作

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

 

6.效果

优点：

1）简化了对象之间的交互。

2）减少子类的生成。

缺点：

1）在具体中介者类中包含了同事之间的交互细节，可能会导致具体中介者类非常复杂，使得系统难以维护。

 

6.案例

cup、声卡、显卡 通过主板进行通信

 

#include <iostream>
#include <string>
using namespace std;

class Colleague;
class Mediator 
{
public:
    //对象在自身改变的情况下，通知Mediator进行变更
    //让我们Mediator这个总线，负责相应的同事对象的交互
    virtual void changed(Colleague* pColleague) = 0;
protected:
    Mediator() {};
};

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

private:
    Mediator* m_pMediator;
};

class SoundCard :public Colleague 
{
public:
    //模拟声卡的工作
    SoundCard(Mediator* pMediator) :Colleague(pMediator) {}
    void soundData(string data) { cout << "声卡在工作" << data << endl; }
};

class VideoCard :public Colleague 
{
public:
    VideoCard(Mediator* pMediator) :Colleague(pMediator) {}
    void VideoData(string data) { cout << "显卡在工作" << data << endl; }
};

class CPU :public Colleague 
{
public:
    CPU(Mediator* pMediator) :Colleague(pMediator) {}
    void executeData(string data[]) 
    {
        m_strVideoData = data[0];
        m_strSoundData = data[1];
        this->getMediator()->changed(this);
    }

    string getVideoData() { return m_strVideoData; }
    string getSoundData() { return m_strSoundData; }
private:
    string m_strVideoData;
    string m_strSoundData;
};

class MotherBoard :public Mediator 
{
public:
    void setCPU(CPU* pCpu) { m_pCPU = pCpu; }
    void setVideoCard(VideoCard* pVC) { m_pVideoCard = pVC; }
    void setSoundCard(SoundCard* pSC) { m_pSoundCard = pSC; }
    void changed(Colleague* pColleague) 
    {
        if (pColleague == m_pCPU) { this->openCPU((CPU*)pColleague); }
    }
private:
void openCPU(CPU* pCPU) 
{
    //主板开始进行各个部件的运行，首先调用CPU，将处理好的数据得到
    string strVideoData = pCPU->getVideoData();
    string strSoundData = pCPU->getSoundData();
    //将这些处理好的数据交付给SoundCard,VideoCard，让他们工作
    m_pVideoCard->VideoData(strVideoData);
    m_pSoundCard->soundData(strSoundData);
}
private:
    CPU* m_pCPU;
    VideoCard* m_pVideoCard;
    SoundCard* m_pSoundCard;
};

int main() 
{
    //创建Mediator
    MotherBoard* pMediator = new MotherBoard;
    //创建同事类的对象
    CPU* pCPU = new CPU(pMediator);
    VideoCard* pVC = new VideoCard(pMediator);
    SoundCard* pSC = new SoundCard(pMediator);
    //让Mediator都知道这些Colleague的对象
    pMediator->setCPU(pCPU);
    pMediator->setSoundCard(pSC);
    pMediator->setVideoCard(pVC);
    //让我们的数据运行起来
    string arr[] = { "好好学习","天天向上" };
    pCPU->executeData(arr);//看上去，好像CPU就在做自己的事情
    system("pause");
    return 0;
}

 

设计模式系列 https://blog.csdn.net/nie2314550441/article/details/105849726