c++设计模式(19)-Mediator模式

来源：互联网发布：枪械百科软件编辑：程序博客网时间：2024/06/05 17:08

Mediator模式典型的结构图为：

图2-1：Mediator Pattern结构图

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

2.3 实现

2.3.1 完整代码示例（code）

Mediator模式实现不是很困难，这里为了方便初学者的学习和参考，将给出完整的实现代码（所有代码采用C++实现，并在VC 6.0下测试运行）。

代码片断1：Colleage.h
//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_

代码片断2：Colleage.cpp
//Colleage.cpp

#include "Mediator.h"

#include "Colleage.h"

#include <iostream>
using namespace std;

Colleage::Colleage()
{
//_sdt = " ";
}

Colleage::Colleage(Mediator* mdt)
{
this->_mdt = mdt;

//_sdt = " ";
}

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;
}

代码片断3：Mediator.h
//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_

代码片断4：Mediator.cpp
//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());
}

代码片断5：main.cpp
//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;
}

2.3.2 代码说明

Mediator模式的实现关键就是将对象Colleague之间的通信封装到一个类种单独处理，为了模拟Mediator模式的功能，这里给每个Colleague对象一个string型别以记录其状态，并通过状态改变来演示对象之间的交互和通信。这里主要就Mediator的示例运行结果给出分析：

1）将ConcreteColleageA对象设置状态“old”，ConcreteColleageB也设置状态“old”；

2）ConcreteColleageA对象改变状态，并在Action中和ConcreteColleageB对象进行通信，并改变ConcreteColleageB对象的状态为“new”；

3）ConcreteColleageB对象改变状态，并在Action中和ConcreteColleageA对象进行通信，并改变ConcreteColleageA对象的状态为“new”；

注意到，两个Colleague对象并不知道它交互的对象，并且也不是显示地处理交互过程，这一切都是通过Mediator对象完成的，示例程序运行的结果也正是证明了这一点。

2.4 讨论

Mediator模式是一种很有用并且很常用的模式，它通过将对象间的通信封装到一个类中，将多对多的通信转化为一对多的通信，降低了系统的复杂性。Mediator还获得系统解耦的特性，通过Mediator，各个Colleague就不必维护各自通信的对象和通信协议，降低了系统的耦合性，Mediator和各个Colleague就可以相互独立地修改了。

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