行为型模式—中介者模式

Posted 浅墨浓香

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了行为型模式—中介者模式相关的知识,希望对你有一定的参考价值。

1. 中介者模式(Mediator Pattern)的定义

(1)定义:用一个中介对象来封装一系统对象交互。中介者使得各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。

     

  ①中介者模式主要用来将同事类之间网状结构变为星状结构,使同事类之间的关系变的清晰一些。

  ②所有对象只跟中介者对象进行通信,相互之间不再有联系,这样也能够集中控制这些对象的交互关系

(2)中介者模式的结构和说明

 

  ①Mediator: 中介者接口。在里面定义各个同事之间交互需要的方法,可以是公共的通信方法,比如changed方法,大家都可以用(一般会传入同事类的this指针),也可以是小范围的交互方法。

  ②ConcreteMediator:具体中介者实现对象。这需要了解并维扩各个同事对象,并负具体的协调各同事对象的交互关系。

  ③Colleague:同事类的定义,通常实现为抽象类,主要负责约束同事对象的类型,并能实现一些具体同事类之间的公共功能。同时,一般会持有中介者的引用

  ④ConcreteColleague:具体的同事类,实现自己的业务,在需要与其他同事通信的时候,就与持有的中介者通信,中介者会负责与其他的同事交互。

【编程实验】班级QQ群

//示意图

    

//UML图

//行为模式——中介者模式
//场景:班级通信

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Colleage; //前向声明

//*******************************************抽象中介者**************************************
//抽象中介者
class Mediator
{
public:
    virtual void addStudent(Colleage* student) = 0;
    //通知
    virtual void notify(Colleage* student) = 0;
    //两个同学私下交流
    virtual void chat(Colleage* student1,Colleage* student2) = 0;
};

//*******************************************抽象同事类**************************************
//抽象同事类
class Colleage
{
private:
    string name;
    string content;
protected:
    Mediator* mediator;
public:
    Colleage(Mediator* mediator, string name="")
    {
        this->mediator = mediator;
        this->name = name;

        this->mediator->addStudent(this);
    }

    string& getName()
    {
        return this->name;
    }

    void setContent(string content)
    {
        this->content = content;
    }

    string& getContent()
    {
        return content;
    }

    virtual void talk() = 0;

    void inform()
    {
        talk();
        mediator->notify(this);
    }
};

//具体的同事类:班长
class Monitor : public Colleage
{
public:
    Monitor(Mediator* mediator, string name=""):Colleage(mediator,name){}

    virtual void talk()
    {
        cout <<"班长 说:" << getContent() << endl;
    }
};

//具体的同事类:团支书
class YouthLeague : public Colleage
{
public:
    YouthLeague(Mediator* mediator, string name=""):Colleage(mediator,name){}

    virtual void talk()
    {
        cout <<"团支书 说:" << getContent() << endl;
    }
};

//具体的同事类:同学A
class StudentA : public Colleage
{
public:
    StudentA(Mediator* mediator, string name=""):Colleage(mediator,name){}

    virtual void talk()
    {
        cout <<"学生A 说:" << getContent() << endl;
    }
};

//具体的同事类:同学A
class StudentB : public Colleage
{
public:
    StudentB(Mediator* mediator, string name=""):Colleage(mediator,name){}

    virtual void talk()
    {
        cout <<"学生B 说:" << getContent() << endl;
    }
};

//具体的中介者(如QQ通讯平台)
class QQMediator: public Mediator
{
private:
    vector<Colleage*> studentList;
public:
    void addStudent(Colleage* student)
    {
        studentList.push_back(student);
    }

    void notify(Colleage* student)
    {
        //student发出通知,其他同学回复
        vector<Colleage*>::iterator iter = studentList.begin();
        while(iter != studentList.end())
        {
            //其他同学的回复
            if(*iter != student)
            {
                (*iter)->talk();
            }
            ++iter;
        }
    }

    //私下交流
    void chat(Colleage* student1,Colleage* student2)
    {
        //学生1说话
        student1->talk();
        //学生2回答
        student2->talk();
    }
};

int main()
{
    //***********************初始化QQ聊天环境********************
    QQMediator qq;
    Monitor mon(&qq,"Minitor");
    YouthLeague youth(&qq,"YouthLeague");
    StudentA stuA(&qq,"StudentA");
    StudentB stuB(&qq, "StudentB");


    //***************班级发通知********************
    mon.setContent("明天下午2点开年段会,收到请回复^^。");
    youth.setContent("知道了,肯定到!!");
    stuA.setContent("收到了,一定准时到!!");
    stuB.setContent("收到了,但明天要去面试,特请假一下!!");

    //开始发通知
    mon.inform();

    //*******************两个同学私下交流**************
    cout << endl << "下面是两个同学的私下交流:" << endl;
    mon.setContent("你觉得咱们地理老师课讲得怎么样?");
    stuA.setContent("我觉得讲的不够生动,还点名,不太好!!!");
    qq.chat(&mon,&stuA);

    return 0;
}

2. 思考中介者模式

(1)中介者模式的本质封装交互。中介者的目的,就是用来封装多个对象的交互,这些交互的处理多在中介者对象里面实现。只要是实现封装对象之间的交互功能,就可用中介者模式,而不必过于拘泥于中介者模式本身的结构。

(2)需要Mediator接口吗

  这取决于是否会提供多个不同的中介者实现。如果中介者实现只有一个的话,而且预计中也没有扩展的需求,那就可以不定义Mediator接口。如果中介者实现不只一个,或者预计有扩展的要求,那么就需要定义Mediator接口。让各个同事类来面向中介者接口编程。

(3)同事关系

  在标准的中介者模式中,将使用中介者对象来交互的那些对象称为同事类,在中介者模式中要求这些类都要继承相同的类,也就是说这些对象从某个角度来讲是同一个类型,算是兄弟对象。

(4)同事和中介者的关系

  ①当一个同事对象发生了改变,需要主动通知中介者,让中介者去处理与其他同事对象相关的交互。

  ②同事对象需要知道中介者对象是谁,反过来,中介者对象也需要知道相关的同事对象,这样才能与同事对象进行交互。

  ③中介者对象与同事对象之间是相互依赖的。

(5)如何实现同事和中介者的通信

  ①同事类持有中介者对象,可以通过Mediator接口中定义一个特殊的通知接口(如changed),并把this当做参数传入,这样在中介者对象里面,就可以去获取这个同事对象的实例或当中的数据了。中介者对象里面记录着各个同事,会根据从changed接口中传入来的对象,判断下一步的动作。

  ②另一种实现方式可以采用观察者模式,把Mediator实现成为观察者,而各个同事类实现成为Subject,这样同事类发生了改变,会通知Mediator。Mediator在接到通知的以后,会与相应的同事对象进行交互。

【编程实验】用电脑看电影

//行为模式——中介者模式
//场景:使用电脑来看电影
//中介者:主板
//同事类:CPU、内存、光驱、显卡、声卡等

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Colleage; //前向声明

//*******************************************抽象中介者**************************************
//抽象中介者
class Mediator
{
public:
    //同事对象在自身改变的时候调用这个接口来通知中介者
    virtual void changed(Colleage* colleague) = 0;
};

//*******************************************抽象同事类**************************************
//抽象同事类
class Colleage
{
protected:
    Mediator* mediator;
public:
    Colleage(Mediator* mediator)
    {
        this->mediator = mediator;
    }
    //获取当前同事类对应的中介者对象
    Mediator& getMediator()
    {
        return *mediator;
    }
};

//具体的同事类:光驱
class CDDriver : public Colleage
{
private:
    string data;
public:
    CDDriver(Mediator* mediator):Colleage(mediator){}

    //读取光盘
    void readCD()
    {
        //逗号前是视频显示的数据,逗号后是声音
        data = "设计模式,值得好好研究";
        //通知中介者(主板),自己的状态发生了改变
        mediator->changed(this);
    }

    string& getData()
    {
        return data;
    }
};

//具体的同事类:CPU
class CPU : public Colleage
{
private:
    string videoData; //分解出来的视频数据
    string soundData; //分解出来的声音数据
public:
    CPU(Mediator* mediator):Colleage(mediator){}

    string& getVideoData()
    {
        return videoData;
    }

    string& getSoundData()
    {
        return soundData;
    }

    //处理数据,把数据分成音频和视频数据
    void executeData(string data)
    {
        int nPos = data.find(",");
        videoData = data.substr(0,nPos);
        soundData = data.substr(nPos+1,data.length()-nPos);
        //通知主板,CPU的工作完成
        mediator->changed(this);
    }
};

//具体的同事类:显卡类
class VideoCard : public Colleage
{
private:
    string data; //被显示的数据
public:
    VideoCard(Mediator* mediator):Colleage(mediator){}

    //显示数据
    void showData(string data)
    {
        cout << "您正在观看的是:" << data << endl;
    }
};

//具体的同事类:声卡类
class SoundCard : public Colleage
{
private:
    string data; //被播放的声音数据
public:
    SoundCard(Mediator* mediator):Colleage(mediator){}

    //显示数据
    void soundData(string data)
    {
        cout << "画外音:" << data << endl;
    }
};

//*************************************具体中介者****************
//主板类
class MainBoard : public Mediator
{
private:
    CDDriver* cdDriver;
    CPU* cpu;
    VideoCard* videoCard;
    SoundCard* soundCard;

    //处理光驱读取数据以后与其他对象的交互
    void opeCDDriverReadData(CDDriver* cd)
    {
        //1.获取光驱读取的数据
        string data = cd->getData();
        //2.把这些数据传给CPU进行处理
        cpu->executeData(data);
    }

    //CPU处理完数据后与其他对象的交互
    void opeCPU(CPU* cpu)
    {
        //1.先取出CPU处理后的数据
        string& videoData = cpu->getVideoData();
        string& soundData = cpu->getSoundData();

        //2. 把数据传递给显卡和声卡展示出来
        videoCard->showData(videoData);
        soundCard->soundData(soundData);
    }

public:
    void setCDDrriver(CDDriver* cdDriver)
    {
        this->cdDriver = cdDriver;
    }

    void setCPU(CPU* cpu)
    {
        this->cpu = cpu;
    }

    void setVideoCard(VideoCard* videoCard)
    {
        this->videoCard = videoCard;
    }

    void setSoundCard(SoundCard* soundCard)
    {
        this->soundCard = soundCard;
    }

    //接收通知
    void changed(Colleage* colleage)
    {
        //从光驱来的通知
        if(colleage == cdDriver)
        {
            opeCDDriverReadData((CDDriver*)colleage);
        }
        else if(colleage == cpu)
        {
            //表示CPU处理完了
            opeCPU((CPU*)colleage);
        }
    }
};

int main()
{
    //1.创建中介者——主板对象
    MainBoard mediator;
    //2.创建同事类
    CDDriver cd(&mediator);
    CPU cpu(&mediator);
    VideoCard vc(&mediator);
    SoundCard sc(&mediator);

    //3.让中介者知道所有的同事
    mediator.setCDDrriver(&cd);
    mediator.setCPU(&cpu);
    mediator.setVideoCard(&vc);
    mediator.setSoundCard(&sc);

    //4.开始看电影,把光盘放入光驱,光驱开始读盘
    cd.readCD();

    return 0;
}

3. 广义的中介者

(1)标准中介者模式的问题

  ①同事对象都要从一个公共的父类继承。在这实际开发中,很多相互交互的对象本身是没有公共父类的,强行加上一个父类,会让这些对象实现起来特别别扭。

  ②同事类必须持有中介者对象吗?在标准的中介者模式中,中介者对象作为属性并通过构造方法注入到同事类中的。而实际开发中,可以把中介者对象做成单例,直接在同事类的方法里面去调用中介者对象,而无须将中介者作为同事类的成员变量。

  ③在实际开发中,很常见的情况是不需要中介者接口的,而且中介者对象也不需要创建多个实例。因为中介者是用来封装和处理同事对象的关系的,它一般被实现为单例。

  ④中介者对象是否需要持有所有的同事?在标准的中介者模式中会将所有的同事类作为成员变量(或保存在链表中)这是一种很强的依赖关系。在实现中,可以在中介者处理的方法里面去创建或获取,或者从参数传入需要的同事对象

  ⑤中介者对象只是提供一个公共的方法来接受同事对象的通知吗?在标准的中介者中只提供一个公共方法,这样还是要去区分到底是哪个同事类发过来的通知。在实际的开发中,通常会提供具体的业务通知方法,这样就不用再去判断到底是什么对象,其具体的什么业务了。

(2)广义的中介者模式(也是简化的中介者模式)

  ①通常去掉同事对象的父类,这样可以让任意对象,只要需要相互交互,就可以成为同事。

  ②通常不定义Mediator接口,把具体的中介者对象实现成单例。

  ③同事对象不再持有中介者,需是在需要的时候直接获取中介者对象并调用;中介者也不再持有同事对象,而是在具体的处理方法里面去创建或者获取,或者从参数传入需要的同事对象。

【编程实验】人事管理

//引入中介者的人事管理示意图

//UML示意图

//源码

//行为模式——中介者模式
//场景:人事管理系统
//一个部门可能有多个人,同时一个人也可以加入多个部门,即
//部门和人员是多对多的关系。因此如果人员和部门直接打交道
//那样人员或部门的内部势必要引用多个部门或人员的引用,这样
//耦合性太强,可以把部门和人员的关系放入中介者中,通过中介者
//来维护部门和人员的关系,这样可以将部门和人员解耦。同时集中
//管理人员和部门之间的关系((如删除某个人或部门时的逻辑)

#include <iostream>
#include <string>
#include <vector>

using namespace std;

//**********************辅助类****************
//描述部门和人员关系的类(相当于数据表的一行记录)
class DepUserModel
{
private:
    //用于部门和人员关系的编号
    string depUserId; //用做主键
    string depId;      //部门编号
    string userId;     //人员编号
public:
    string& getDepUserId()
    {
        return depUserId;
    }
    void setDepUserId(string depUserId)
    {
        this->depUserId = depUserId;
    }

    string& getDepId()
    {
        return depId;
    }
    void setDepId(string depId)
    {
        this->depId = depId;
    }

    string& getUserId()
    {
        return userId;
    }

    void setUserId(string userId)
    {
        this->userId = userId;
    }
};

//**********************中介者****************************
//实现部门和人员交互的中介者实现类
class DepUserMediatorImpl
{
private:
    static DepUserMediatorImpl* mediator;

    //构造函数私有化
    DepUserMediatorImpl()
    {
        initTestData(); //初始化测试数据
    }
private:
    vector<DepUserModel*> depUser;

    void initTestData()
    {
        //准备一些测试数据
        DepUserModel* dum = new DepUserModel();
        dum->setDepUserId("du1");
        dum->setDepId("d1");
        dum->setUserId("u1");
        depUser.push_back(dum);

        dum = new DepUserModel();
        dum->setDepUserId("du2");
        dum->setDepId("d1");
        dum->setUserId("u2");
        depUser.push_back(dum);

        dum = new DepUserModel();
        dum->setDepUserId("du3");
        dum->setDepId("d2");
        dum->setUserId("u3");
        depUser.push_back(dum);

        dum = new DepUserModel();
        dum->setDepUserId("du4");
        dum->setDepId("d2");
        dum->setUserId("u4");
        depUser.push_back(dum);

        dum = new DepUserModel();
        dum->setDepUserId("du5");
        dum->setDepId("d2");
        dum->setUserId("u1");
        depUser.push_back(dum);
    }
public:
    //完成因撤销部门的操作所引起的与人员的交互,需要去除相应的关系
    bool deleteDep(string depId)
    {
        //为了演示简单,部门撤销后,原部门的人员怎么处理这里不管了
        //到记录部门和人员关系的集合里面,寻找跟这个部门相关的人员
        vector<DepUserModel*>::iterator iter = depUser.begin();
        while(iter != depUser.end())
        {
            if( (*iter)->getDepId() == depId)
            {
                delete (*iter);
                iter = depUser.erase(iter);
            }
            else
                ++iter;
        }
        return true;
    }

    //完成因人员离职引起的与部门交互
    bool deleteUser(string userId)
    {
        //到记录部门和人员关系的集合里面,寻找跟这个人员相关
        //的部门,并删除那些记录。
        vector<DepUserModel*>::iterator iter=depUser.begin();
        while(iter != depUser.end())
        {
            if((*iter)->getUserId() == userId)
            {
                delete (*iter);
                iter = depUser.erase(iter);
            }
            else
                ++iter;
        }
        return true;
    }

    //完成因人员调换部门引起的与部门交互
    bool changeDep(string userId,string oldDepId,string newDepId)
    {
        //本例不去实现了
        return false;
    }

    //完成因部门合并操作所引起的与人员的交互
    //@param depIds 需要合并的部门编号的集合
    //@param newDep 合并后新的部门对象
    bool joinDep(vector<string> depIds, string** newDepId)
    {
        //本例不去实现了
        return false;
    }

    //测试用,在内部打印显示一个部门下的所有人员
    void showDepUsers(string depId)
    {
        vector<DepUserModel*>::iterator iter=depUser.begin();
        while(iter != depUser.end())
        {
             if((*iter)->getDepId() == depId)
             {
                  cout <<"部门编号=" << depId
                       <<"下面拥有人员,其编号是:"
                       <<(*iter)->getUserId() << endl;
             }
             ++iter;
        }
    }

    //测试用,在内部打印显示一个人员所属的部门
    void showUserDeps(string userId)
    {
        vector<DepUserModel*>::iterator iter=depUser.begin();
        while(iter != depUser.end())
        {
             if((*iter)->getUserId() == userId)
             {
                  cout <<"人员编号=" << userId
                       <<"所属的部门编号是:"
                       <<(*iter)->getDepId() << endl;
             }
             ++iter;
        }
    }

public:
    static DepUserMediatorImpl* getInstance()
    {
        if(mediator == NULL)
            mediator = new DepUserMediatorImpl();

        return mediator;
    }
};

DepUserMediatorImpl* DepUserMediatorImpl::mediator = NULL;

//部门类
class Dep
{
private:
    string depId;   //部门编号
    string depName; //部门名称
public:
    void setDepId(string depId)
    {
        this->depId = depId;
    }

    string& getDepId()
    {
        return depId;
    }

    void setDepName(string depName)
    {
        this->depName = depName;
    }

    string& getDepName()
    {
        return depName;
    }

    //撤销部门
    bool deleteDep()
    {
        //1.部门类只与中介打交通,先通过中介者去除掉所有与这个部门相关的部门和人员的关系
        DepUserMediatorImpl* mediator = DepUserMediatorImpl::getInstance();
        mediator->deleteDep(depId);

        //2.真正删除掉这个部门

        return true;
    }
};

//人员类
class User
{
private:
    string userId;
    string userName;
public:
    string& getUserId()
    {
        return userId;
    }

    void setUserId(string userId)
    {
        this->userId = userId;
    }

    string& getUserName()
    {
        <

以上是关于行为型模式—中介者模式的主要内容,如果未能解决你的问题,请参考以下文章

行为型模式之中介者模式

《大话设计模式》笔记——行为型模式2

行为型模式-中介模式

行为型模式-中介模式

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

设计模式(17)--Mediator(中介者模式)行为型