設計模式（二十三）——中介者模式

設計模式（二十三）——中介者模式

1、中介者模式簡介

一、中介者模式簡介

    中介者模式用一箇中介對象來封裝一系列的對象交互。中介者使各對象不須要顯式地相互引用，從而使其耦合鬆散，並且能夠獨立地改變它們之間的交互。

    中介者模式中，每一個同事對象維護一個中介者，當要進行通訊時，每一個具體的同事直接向中介者發信息，至於信息發到哪裏，則由中介者來決定。

    中介者模式就是迪米特法則的一個典型應用。在中介者模式中，經過創造出一箇中介者對象，將系統中有關的對象所引用的其餘對象數目減小到最少，使得一個對象與其同事之間的相互做用被這個對象與中介者對象之間的相互做用所取代。所以，中介者模式就是迪米特法則的一個典型應用。
    經過引入中介者對象，能夠將系統的網狀結構變成以中介者爲中心的星形結構，中介者承擔了中轉做用和協調做用。中介者類是中介者模式的核心，對整個系統進行控制和協調，簡化了對象之間的交互，還能夠對對象間的交互進行進一步的控制。

2、中介者模式角色

    抽象中介者(Mediator)：抽象中介者定義了同事對象到中介者對象的接口。
    具體中介者(ConcreteMediator): 實現抽象類的方法，須要知道全部具體同事類，並從具體同事接收消息，向具體同事對象發出命令。具體中介者經過協調各同事對象實現協做行爲。
    抽象同事類(Colleague class): 定義同事類接口，定義各同事的公有方法.
    具體同事類(ConcreteColleague): 實現抽象同事類中的方法。每個同事類須要知道中介者對象；每一個具體同事類只須要了解本身的行爲，而不須要了解其餘同事類的狀況。每個同事對象在需與其餘的同事通訊的時候，與它的中介者通訊。同事類之間必須經過中介者才能進行消息傳遞。

三、中介者模式優缺點

中介者模式的優勢：

    A、適當地使用中介者模式能夠避免同事類之間的過分耦合，使得各同事類之間能夠相對獨立地使用。

    B、使用中介者模式能夠將對象間一對多的關聯轉變爲一對一的關聯，使對象間的關係易於理解和維護。

    C、使用中介者模式能夠將對象的行爲和協做進行抽象，可以比較靈活的處理對象間的相互做用。

    D、使控制集中化。中介者模式將交互的複雜性變爲中介者的複雜性

中介者模式的缺點：

    控制集中化，使得中介者變得複雜而難以維護。

四、中介者模式使用場景

中介者模式使用場景：

    A、系統中對象之間存在複雜的引用關係，產生的相互依賴關係結構混亂且難以理解

    B、一個對象因爲引用了其餘不少對象而且直接和這些對象通訊，致使難以複用該對象

    C、想經過一箇中間類來封裝多個類中的行爲，而又不想生成太多的子類

2、中介者模式實現

Mediator抽象中介者：

#ifndef MEDIATOR_H
#define MEDIATOR_H
#include <string>
#include <iostream>
using namespace std;
class Colleage;
 
//抽象中介者類
class Mediator
{
public:
    //向同事發送消息接口
    virtual void sendMessage(string msg, Colleage* colleage) = 0;
protected:
    Mediator(){}
};
 
#endif // MEDIATOR_H

 

ConcreteMediator具體中介者：

#ifndef CONCRETEMEDIATOR_H
#define CONCRETEMEDIATOR_H
#include "Mediator.h"
#include "Colleage.h"
 
//具體中介者類
class ConcreteMediator : public Mediator
{
public:
    virtual void sendMessage(string msg, Colleage* colleage)
    {
        if(colleage == m_pColleageA)
        {   //若是發送消息的爲同事A，則由同事B接收消息
            m_pColleageB->getMessage(msg);
        }
        else if(colleage == m_pColleageB)
        {
            //若是發送消息的爲同事B，則由同事A接收消息
            m_pColleageA->getMessage(msg);
        }
    }
    void setColleageA(Colleage* colleage)
    {
        m_pColleageA = colleage;
    }
    void setColleageB(Colleage* colleage)
    {
        m_pColleageB = colleage;
    }
private:
    Colleage* m_pColleageA;//同事A
    Colleage* m_pColleageB;//同事B
};
 
#endif // CONCRETEMEDIATOR_H

 

Colleage抽象同事：

#ifndef COLLEAGE_H
#define COLLEAGE_H
#include "Mediator.h"
 
//抽象同事類
class Colleage
{
public:
    //設置者
    void setMediator(Mediator* mediator)
    {
        m_pMediator = mediator;
    }
    //向中介者發送消息接口
    virtual void sendMessage(string msg) = 0;
    //從中介者獲取消息接口
    virtual void getMessage(string msg) = 0;
 
protected:
    Colleage(Mediator* mediator)
    {
        m_pMediator = mediator;
    }
protected:
    Mediator* m_pMediator;//中介
};
 
#endif // COLLEAGE_H

ConcreteColleageA具體同事類：

#ifndef CONCRETECOLLEAGEA_H
#define CONCRETECOLLEAGEA_H
#include "Colleage.h"
 
//具體同事類
class ConcreteColleageA : public Colleage
{
public:
    ConcreteColleageA(Mediator* mediator):Colleage(mediator)
    {
    }
    void sendMessage(string msg)
    {
        //要發送的消息由中介者轉發
        m_pMediator->sendMessage(msg, this);
    }
    void getMessage(string msg)
    {
        cout << "ConcreteColleageA receive an message: " << msg << endl;
    }
};
 
#endif // CONCRETECOLLEAGEA_H

 

ConcreteColleageB具體同事類：

#ifndef CONCRETECOLLEAGEB_H
#define CONCRETECOLLEAGEB_H
#include "Colleage.h"
 
//具體同事類
class ConcreteColleageB : public Colleage
{
public:
    ConcreteColleageB(Mediator* mediator):Colleage(mediator)
    {
    }
    void sendMessage(string msg)
    {
        //要發送的消息由中介者轉發
        m_pMediator->sendMessage(msg, this);
    }
    void getMessage(string msg)
    {
        cout << "ConcreteColleageB receive an message: " << msg << endl;
    }
};
 
#endif // CONCRETECOLLEAGEB_H

客戶調用程序：

#include "Mediator.h"
#include "Colleage.h"
#include "ConcreteMediator.h"
#include "ConcreteColleageA.h"
#include "ConcreteColleageB.h"
 
using namespace std;
 
int main()
{
    //建立中介者
    ConcreteMediator* mediator = new ConcreteMediator();
    //建立同事
    Colleage* coleageA = new ConcreteColleageA(mediator);
    Colleage* coleageB = new ConcreteColleageB(mediator);
    //設置中介者管理的同事對象
    mediator->setColleageA(coleageA);
    mediator->setColleageB(coleageB);
    //同事發送消息
    coleageA->sendMessage("A");
    coleageB->sendMessage("B");
 
    delete mediator;
    delete coleageA;
    delete coleageB;
    return 0;
}