Mediator模式

Mediator模式

    Mediator模式是一种很有用的模式，它通过将对象间的通信封装到一个类中，将多对多的通信转化为一对多的通信，降低了系统的复杂性。

    面向对象设计激励将行为分布到各个对象中，但这种分布可能会导致对象间有许多连接，在最坏的情况下，每一个对象都知道其他所有对象，

想到了"图"有木有。。。Mediator模式用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显示地相互引用，从而使其耦合松散，

从而可以独立地改变它们之间的交互，还有一个优点就是控制集中、便于管理。

C++代码示例：

//colleage.h

#ifndef COLLEAGE_H
#define COLLEAGE_H

#include <string>
#include <iostream>

using namespace std;

class Mediator;

class Colleage
{
public:
    virtual ~Colleage();
    virtual void Action() = 0;
    virtual void setState(const string &sta) = 0;
    virtual string getState() = 0;
protected:
    Colleage();
    Colleage(Mediator *med);
    Mediator* m_med;
};

class ConcreteColleageA : public Colleage{

public:
    ConcreteColleageA();
    ConcreteColleageA(Mediator *med);
    ~ConcreteColleageA();
    void Action();
    void setState(const string &sta);
    string getState();
private:
    string m_str;
};

class ConcreteColleageB : public Colleage{

public:
    ConcreteColleageB();
    ConcreteColleageB(Mediator* med);
    ~ConcreteColleageB();
    void Action();
    void setState(const string &sta);
    string getState();
private:
    string m_str;
};

#endif // COLLEAGE_H

//colleage.cpp

#include "colleage.h"
#include "mediator.h"

Colleage::Colleage(){

}

Colleage::Colleage(Mediator *med){

    this->m_med = med;
}

Colleage::~Colleage(){

}

ConcreteColleageA::ConcreteColleageA(){

}

ConcreteColleageA::~ConcreteColleageA(){

}

ConcreteColleageA::ConcreteColleageA(Mediator *med)
    : Colleage(med){

}

string ConcreteColleageA::getState(){

    return m_str;
}

void ConcreteColleageA::setState(const string &sta){

    m_str = sta;
}

void ConcreteColleageA::Action(){

    m_med->DoActionFromAtoB();
    cout << "State of ConcreteColleageB: " << this->getState() << endl;
}

ConcreteColleageB::ConcreteColleageB(){

}

ConcreteColleageB::~ConcreteColleageB(){

}

ConcreteColleageB::ConcreteColleageB(Mediator *med)
    : Colleage(med){

}

void ConcreteColleageB::Action(){

    m_med->DoActionFromBtoA();
    cout << "State of ConcreteColleageA: " << this->getState() << endl;
}

string ConcreteColleageB::getState(){

    return m_str;
}

void ConcreteColleageB::setState(const string &sta){

    m_str = sta;
}

//mediator.h

#ifndef MEDIATOR_H
#define MEDIATOR_H

class Colleage;

class Mediator
{
public:
    virtual ~Mediator();
    virtual void DoActionFromAtoB() = 0;
    virtual void DoActionFromBtoA() = 0;
protected:
    Mediator();
};

class ConcreteMediator : public Mediator{

public:
    ConcreteMediator();
    ConcreteMediator(Colleage* collA,Colleage* collB);
    ~ConcreteMediator();
    void setConcreteColleageA(Colleage* collA);
    void setConcreteColleageB(Colleage* collB);
    Colleage* getConcreteColleageA();
    Colleage* getConcreteColleageB();
    void introColleage(Colleage* collA,Colleage* collB);
    void DoActionFromAtoB();
    void DoActionFromBtoA();
private:
    Colleage *m_collA;
    Colleage *m_collB;
};

#endif // MEDIATOR_H

//mediator.cpp

#include "mediator.h"
#include "colleage.h"

Mediator::Mediator(){

}

Mediator::~Mediator(){

}

ConcreteMediator::ConcreteMediator(){

}

ConcreteMediator::~ConcreteMediator(){

}

ConcreteMediator::ConcreteMediator(Colleage *collA, Colleage *collB){

    this->m_collA = collA;
    this->m_collB = collB;
}

void ConcreteMediator::DoActionFromAtoB(){

    m_collB->setState(m_collA->getState());
}

void ConcreteMediator::DoActionFromBtoA(){

    m_collA->setState(m_collB->getState());
}

void ConcreteMediator::setConcreteColleageA(Colleage *collA){

    this->m_collA = collA;
}

void ConcreteMediator::setConcreteColleageB(Colleage *collB){

    this->m_collB = collB;
}

Colleage* ConcreteMediator::getConcreteColleageA(){

    return m_collA;
}

Colleage* ConcreteMediator::getConcreteColleageB(){

    return m_collB;
}

void ConcreteMediator::introColleage(Colleage *collA, Colleage *collB){

    this->m_collA = collA;
    this->m_collB = collB;
}

//main.cpp

#include "mediator.h"
#include "colleage.h"
#include <iostream>

int main()
{
    ConcreteMediator* m = new ConcreteMediator();
    ConcreteColleageA* ccA = new ConcreteColleageA(m);
    ConcreteColleageB* ccB = new ConcreteColleageB(m);
    m->introColleage(ccA,ccB);

    ccA->setState("old");
    ccB->setState("old");
    ccA->Action();
    ccB->Action();
    cout << endl;

    ccA->setState("new");
    ccA->Action();
    ccB->Action();
    cout << endl;

    ccB->setState("old");
    ccB->Action();
    ccB->Action();

    return 0;
}

运行结果：