Mediator:中介者模式,当多个对象彼此间都有联系的时候,我们就可以应用Mediator将对象间的多对多关系转换为 一对多的关系,这样做,可以使各个对象间的耦合松散。统一管理对象间的通信协议。但也可能使得Mediator对象 成为一个系统中的庞然大物,难以维护。
好,我们现在来看一个实例。下面有三个对象:A,B,C。他们之间的关系是相互的,每个对象都知道其余的两个对象,都可以和其余的对象打交道。 我们先看看不使用Mediator模式的代码,这样的代码可能会产生混乱。 // A.H 类A 的头文件,下面的类B和类C的结构相同,只是为了演示出三个类之间“纠缠不清”的关系
#ifndef _A_H
#define
_A_H
class
B;
class
C;
class
A
...
{ public : void SetColleage(B * b, C * c); // 设置同事(协助者),也就是需要打交道的对象 void ACallB(); // 调用协助者B的服务 void ACallC(); // 调用协助者C的服务 void Function(); // 自己本身的服务 private : B * _b; C * _c; }
;
#endif
// A.CPP
#include
"
a.h
"
#include
"
b.h
"
#include
"
c.h
"
#include
<
iostream
>
using
namespace
std;
void
A::SetColleage(B
*
b, C
*
c)
...
{ _b = b; _c = c; }
void
A::ACallB()
...
{ cout << " A call " ; _b -> Function(); }
void
A::ACallC()
...
{ cout << " A call " ; _c -> Function(); }
void
A::Function()
...
{ cout << " A's Func! " << endl; }
下面的B.H、B.CPP、C.H、C.CPP都和上面两个文件相似,下面给出这4个文件的完整内容// B.H
#ifndef _B_H
#define
_B_H
class
A;
class
C;
class
B
...
{ public : void SetColleage(A * a, C * c); void BCallA(); void BCallC(); void Function(); private : A * _a; C * _c; }
;
#endif
// B.CPP
#include
"
a.h
"
#include
"
b.h
"
#include
"
c.h
"
#include
<
iostream
>
using
namespace
std;
void
B::SetColleage(A
*
a, C
*
c)
...
{ _a = a; _c = c; }
void
B::BCallA()
...
{ cout << " B call " ; _a -> Function(); }
void
B::BCallC()
...
{ cout << " B call " ; _c -> Function(); }
void
B::Function()
...
{ cout << " B's Func! " << endl; }
// C.H
#ifndef _C_H
#define
_C_H
class
A;
class
B;
class
C
...
{ public : void SetColleage(A * a, B * b); void CCallA(); void CCallB(); void Function(); private : A * _a; B * _b; }
;
#endif
// C.CPP
#include
"
a.h
"
#include
"
b.h
"
#include
"
c.h
"
#include
<
iostream
>
using
namespace
std;
void
C::SetColleage(A
*
a, B
*
b)
...
{ _a = a; _b = b; }
void
C::CCallA()
...
{ cout << " C call " ; _a -> Function(); }
void
C::CCallB()
...
{ cout << " C call " ; _b -> Function(); }
void
C::Function()
...
{ cout << " C's Func! " << endl; }
从上面三个类可以看出来,他们之间彼此都有关系,都可以和另外两个类对象打交道。在现实的软件系统中也可能会出现这种情况,整个系统的类间都有耦合性,最终导致整个系统变成一个耦合性很强的系统,完全没有重用可言。由于这种弊端,我们可以运用Mediator模式来解耦,这属于下篇文章的内容,现在我们先来看看怎么调用上面的这些类。
// main.CPP
#include
<
iostream
>
using
namespace
std; #include
"
a.h
"
#include
"
b.h
"
#include
"
c.h
"
void
main()
...
{ A a; B b; C c; a.SetColleage( & b, & c); b.SetColleage( & a, & c); c.SetColleage( & a, & b); a.ACallB(); a.ACallC(); b.BCallA(); b.BCallC(); c.CCallA(); c.CCallB(); }
好了,从这个调用可以看出来,他们之间的耦合性非常强,这里只是三个对象,而且调用的方式比较统一(因为是例子程序),我们还能把他们的关系给搞清楚,但在现实的软件开发中,往往类间的关系比这里的复杂多了,这个时候我们就要“剪”断这些错乱的关系,而“剪刀”就是Mediator模式。 (未完代续)