应用环境:
程序中可能会出现的类间关系过于复杂,问题的所在就是类之间被互相引用而导致混乱,这显然就是多对多的关系。
我们要解决混乱,就要把他们的关系简化为一对多的关系。 充当这个角色的就是Mediator。
Mediator的核心思想就是把错综复杂的类间的关系独立 出来,使得他们的关系清晰化。
好处 :
1,将系统按功能分割成更小的对象,符合类的最小设计原则
2,对关联对象的集中控制
3,减小类的耦合程度,明确类之间的相互关系:当类之间的关系过于复杂时,其中任何一个类的修改都会影响到其他类,不符合类的设计的开闭原则 ,而Mediator模式将原来相互依存的多对多的类之间的关系简化为Mediator控制类与其他关联类的一对多的关系,当其中一个类修改时,可以对其 他关联类不产生影响(即使有修改,也集中在Mediator控制类)。
4,有利于提高类的重用性
5. 如果类间的交互协议有变化,则只修改Mediator类就行了。
缺点 :
在于Mediator 类,因为所有的交互都转移到Mediator中,他的复杂性可想而知,搞不好会变成一个庞然大物,难以维护。
与 外观模式对比:
1.中介者模式解决的是多个对象之间的通信问题,减少类之间的关联
外观模式解决的是子系统的接口复杂度问题
2.中介者模式中对象可以向中介者请求
外观模式中对象不会对外观有任何协作请求
类图:
// Mediator.H
#define _MEDIATOR_H
class A;
class B;
class C;
class Mediator
{
public :
Mediator(A * a, B * b, C * c);
void ACallB();
void ACallC();
void BCallA();
void BCallC();
void CCallA();
void CCallB();
private :
A * _a;
B * _b;
C * _c;
} ;
#endif
// Mediator.CPP
using namespace std;
#include " a.h "
#include " b.h "
#include " c.h "
#include " Mediator.h "
Mediator::Mediator(A * a, B * b, C * c)
{
_a = a;
_b = b;
_c = c;
}
void Mediator::ACallB()
{
cout << " A call " ;
_b -> Function();
}
void Mediator::ACallC()
{
cout << " A call " ;
_c -> Function();
}
void Mediator::BCallA()
{
cout << " B call " ;
_a -> Function();
}
void Mediator::BCallC()
{
cout << " B call " ;
_c -> Function();
}
void Mediator::CCallA()
{
cout << " C call " ;
_a -> Function();
}
void Mediator::CCallB()
{
cout << " C call " ;
_b -> Function();
}
void main()
{
A a;
B b;
C c;
Mediator m( & a, & b, & c);
a.SetMediator( & m);
b.SetMediator( & m);
c.SetMediator( & m);
a.ACallB();
a.ACallC();
b.BCallA();
b.BCallC();
c.CCallA();
c.CCallB();
}
我们看到,main() 函数写在 Mediator.CPP 中, 里面的调用基本上和上一篇的调用一样,唯一不同的是多了Mediator对象的加入。a、b、c 三个对象也不需要设置两个协助者了,只需要设置一个Mediator就行了,而调用和上篇完全一样(当然在内部实现是不一样的,但在接口的看来,它们是没 什么变化的),这样就把三个类之间复杂的关系解开了。
我们再看看其他三个类的变化,先看看类A,其余两个是差不多的。
// A.H
#define _A_H
class B;
class C;
class Mediator;
class A
{
public :
void SetMediator(Mediator * m);
void ACallB();
void ACallC();
void Function();
private :
B * _b;
C * _c;
Mediator * _m;
} ;
#endif
// A.CPP
#include " b.h "
#include " c.h "
#include " Mediator.h "
#include < iostream >
using namespace std;
void A::SetMediator(Mediator * m)
{
_m = m;
}
void A::ACallB()
{
_m -> ACallB();
}
void A::ACallC()
{
_m -> ACallC();
}
void A::Function()
{
cout << " A's Func! " << endl;
}
可以看看类A中原来调用其他类的服务,现在都变成了调用 Mediator 中的服务了,再看看 Mediator 的实现,就应该会明白这个模式的思想所在了。
下面再看看其他两个类的实现:
// B.H
#define _B_H
class A;
class C;
class Mediator;
class B
{
public :
void SetMediator(Mediator * m);
void BCallA();
void BCallC();
void Function();
private :
A * _a;
C * _c;
Mediator * _m;
} ;
#endif
// B.CPP
#include " b.h "
#include " c.h "
#include " Mediator.h "
#include < iostream >
using namespace std;
void B::SetMediator(Mediator * m)
{
_m = m;
}
void B::BCallA()
{
_m -> BCallA();
}
void B::BCallC()
{
_m -> BCallC();
}
void B::Function()
{
cout << " B's Func! " << endl;
}
// C.H
#define _C_H
class A;
class B;
class Mediator;
class C
{
public :
void SetMediator(Mediator * m);
void CCallA();
void CCallB();
void Function();
private :
A * _a;
B * _b;
Mediator * _m;
} ;
#endif
// C.CPP
#include " b.h "
#include " c.h "
#include " Mediator.h "
#include < iostream >
using namespace std;
void C::SetMediator(Mediator * m)
{
_m = m;
}
void C::CCallA()
{
_m -> CCallA();
}
void C::CCallB()
{
_m -> CCallB();
}
void C::Function()
{
cout << " C's Func! " << endl;
}