设计模式解析之——Mediator模式（k_eckel转自微软高校博客K_eckel's mindview）

0 引言

0.1 目的

       本文档给出设计模式之——Mediator模式的简化诠释，并给出其C++实现。

0.2 说明

Project	Design Pattern Explanation（By K_Eckel）
Authorization	Free Distributed but Ownership Reserved
Date	2005-04-05（Cherry blossom is Beautiful）
Test Bed	MS Visual C++ 6.0

0.3 参考

       在本文档的写作中，参考了以下的资源，在此列出表示感谢：

u       书籍

[GoF 2000]：GoF,Design Patterns-Elements of Reusable Object-Oriented Software

Addison-Wesley 2000/9.

        [Martine 2003]：Robert C.Martine, Agile Software Development Principles, Patterns, and Practices, Pearson Education, 2003.

0.4 联系作者

Author	K_Eckel
State	Candidate for Master’s Degree School of Computer Wuhan University
E_mail	frwei@whu.edu.cn

2 Mediator模式

2.1 问题

       在面向对象系统的设计和开发过程中，对象之间的交互和通信是最为常见的情况，因为对象间的交互本身就是一种通信。在系统比较小的时候，可能对象间的通信不是很多、对象也比较少，我们可以直接硬编码到各个对象的方法中。但是当系统规模变大，对象的量变引起系统复杂度的急剧增加，对象间的通信也变得越来越复杂，这时候我们就要提供一个专门处理对象间交互和通信的类，这个中介者就是Mediator模式。Mediator模式提供将对象间的交互和通讯封装在一个类中，各个对象间的通信不必显势去声明和引用，大大降低了系统的复杂性能（了解一个对象总比深入熟悉n个对象要好）。另外Mediator模式还带来了系统对象间的松耦合，这些将在讨论中详细给出。

2.2 模式选择

       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设计中的每个类的职责要单一和集中的原则。