mediator模式-调停者模式

应用环境：

程序中可能会出现的类间关系过于复杂，问题的所在就是类之间被互相引用而导致混乱，这显然就是多对多的关系。

我们要解决混乱，就要把他们的关系简化为一对多的关系。 充当这个角色的就是Mediator。

 

Mediator的核心思想就是把错综复杂的类间的关系独立 出来，使得他们的关系清晰化。

好处 :

1，将系统按功能分割成更小的对象，符合类的最小设计原则
2，对关联对象的集中控制
3，减小类的耦合程度，明确类之间的相互关系：当类之间的关系过于复杂时，其中任何一个类的修改都会影响到其他类，不符合类的设计的开闭原则 ，而Mediator模式将原来相互依存的多对多的类之间的关系简化为Mediator控制类与其他关联类的一对多的关系，当其中一个类修改时，可以对其 他关联类不产生影响（即使有修改，也集中在Mediator控制类）。
4，有利于提高类的重用性

5. 如果类间的交互协议有变化，则只修改Mediator类就行了。

 

缺点 :

在于Mediator 类，因为所有的交互都转移到Mediator中，他的复杂性可想而知，搞不好会变成一个庞然大物，难以维护。

 

与 外观模式对比：

 

1.中介者模式解决的是多个对象之间的通信问题，减少类之间的关联
    外观模式解决的是子系统的接口复杂度问题

2.中介者模式中对象可以向中介者请求
   外观模式中对象不会对外观有任何协作请求

 

类图：

 

// Mediator.H

#ifndef _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

#include  < iostream >
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

#ifndef _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  " a.h "
#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

#ifndef _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  " a.h "
#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

#ifndef _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  " a.h "
#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;
}