20.中介模式--Mediator

Mediator模式：

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

Mediator模式典型的结构图为：



Mediator模式的实现代码如下：

//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();

private:

};

class ConcreteMediator:public Mediator

{

public:

ConcreteMediator();

ConcreteMediator(Colleage* clgA,Colleage* clgB);

~ConcreteMediator();

void SetConcreteColleageA(Colleage* clgA);

void SetConcreteColleageB(Colleage* clgB);

Colleage* GetConcreteColleageA();

Colleage* GetConcreteColleageB();

void IntroColleage(Colleage* clgA,Colleage* clgB);

void DoActionFromAtoB();

void DoActionFromBtoA();

protected:

private:

Colleage* _clgA;

Colleage* _clgB;

};

#endif //~_MEDIATOR_H

//Mediator.cpp

#include "Mediator.h"

#include "Colleage.h"

Mediator::Mediator()

{ }

Mediator::~Mediator()

{ }

ConcreteMediator::ConcreteMediator()

{ }

ConcreteMediator::~ConcreteMediator()

{ }

ConcreteMediator::ConcreteMediator(Colleage* clgA,Colleage* clgB)

{

this->_clgA = clgA;

this->_clgB = clgB;

}

void ConcreteMediator::DoActionFromAtoB()

{

_clgB->SetState(_clgA->GetState());

}

void ConcreteMediator::SetConcreteColleageA(Colleage* clgA)

{

this->_clgA = clgA;

}

void ConcreteMediator::SetConcreteColleageB(Colleage* clgB)

{

this->_clgB = clgB;

}

Colleage* ConcreteMediator::GetConcreteColleageA()

{

return _clgA;

}

Colleage* ConcreteMediator::GetConcreteColleageB()

{

return _clgB;

}

void ConcreteMediator::IntroColleage(Colleage* clgA,Colleage* clgB)

{

this->_clgA = clgA;

this->_clgB = clgB;

}

void ConcreteMediator::DoActionFromBtoA()

{

_clgA->SetState(_clgB->GetState());

}

// Colleage.h

#ifndef _COLLEAGE_H_

#define _COLLEAGE_H_

#include <string>

using namespace std;

class Mediator;

class Colleage

{

public:

virtual ~Colleage();

virtual void Aciton() = 0;

virtual void SetState(const string& sdt) = 0;

virtual string GetState() = 0;

protected:

Colleage();

Colleage(Mediator* mdt);

Mediator* _mdt;

private:

};

class ConcreteColleageA:public Colleage

{

public:

ConcreteColleageA();

ConcreteColleageA(Mediator* mdt);

~ConcreteColleageA();

void Aciton();

void SetState(const string& sdt);

string GetState();

protected:

private:

string _sdt;

};

class ConcreteColleageB:public Colleage

{

public:

ConcreteColleageB();

ConcreteColleageB(Mediator* mdt);

~ConcreteColleageB();

void Aciton();

void SetState(const string& sdt);

string GetState();

protected:

private:

string _sdt;

};

#endif //~_COLLEAGE_H_

//Colleage.cpp

#include "Mediator.h"

#include "Colleage.h"

#include <iostream>

using namespace std;

Colleage::Colleage()

{

}

Colleage::Colleage(Mediator* mdt)

{

this->_mdt = mdt;

}

Colleage::~Colleage()

{

}

ConcreteColleageA::ConcreteColleageA()

{

}

ConcreteColleageA::~ConcreteColleageA()

{

}

ConcreteColleageA::ConcreteColleageA(Mediator* mdt):Colleage(mdt)

{

}

string ConcreteColleageA::GetState()

{

return _sdt;

}

void ConcreteColleageA::SetState(const string& sdt)

{

_sdt = sdt;

}

void ConcreteColleageA::Aciton()

{

_mdt->DoActionFromAtoB();

cout<<"State of ConcreteColleageB:"<<" "<<this->GetState()<<endl;

}

ConcreteColleageB::ConcreteColleageB()

{

}

ConcreteColleageB::~ConcreteColleageB()

{

}

ConcreteColleageB::ConcreteColleageB(Mediator* mdt):Colleage(mdt)

{

}

void ConcreteColleageB::Aciton()

{

_mdt->DoActionFromBtoA();

cout<<"State of ConcreteColleageB:"<<" "<<this->GetState()<<endl;

}

string ConcreteColleageB::GetState()

{

return _sdt;

}

void ConcreteColleageB::SetState(const string& sdt)

{

_sdt = sdt;

}

//main.cpp

#include "Mediator.h"

#include "Colleage.h"

#include <iostream>

using namespace std;

int main(int argc,char* argv[])

{

ConcreteMediator* m = new ConcreteMediator();

ConcreteColleageA* c1 = new ConcreteColleageA(m);

ConcreteColleageB* c2 = new ConcreteColleageB(m);

m->IntroColleage(c1,c2);

c1->SetState("old");

c2->SetState("old");

c1->Aciton();

c2->Aciton();

cout<<endl;

c1->SetState("new");

c1->Aciton();

c2->Aciton();

cout<<endl;

c2->SetState("old");

c2->Aciton();

c1->Aciton();

return 0;

}

Mediator模式中，每个Colleague维护一个Mediator，当要进行交互，例如图中ConcreteColleagueA和ConcreteColleagueB之间的交互就可以通过ConcreteMediator提供的DoActionFromAtoB来处理，ConcreteColleagueA和ConcreteColleagueB不必维护对各自的引用，甚至它们也不知道各个的存在。Mediator通过这种方式将多对多的通信简化为了一（Mediator）对多（Colleague）的通信。

Mediator模式还有一个很显著额特点就是将控制集中，集中的优点就是便于管理，也正式符合了OO设计中的每个类的职责要单一和集中的原则。

但其缺点也很明显，由于ConCreteMediator将控制集中化，于是就把交互复杂性变为了中介者的复杂性，这就使得中介者变得比任何一个ConcreteColleague都复杂。