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;

}

mediator模式-调停者模式相关推荐

设计模式（十一）中介者模式(调停者模式)
1. 中介者模式定义定义:用一个中介者对象来封装一系列的对象交互.中介者使得各对象不需要显式地相互引用,从而使其松散耦合,而且可以独立地改变它们之间的交互. 中介者模式结构图如下图所示. 在中介者模 ...
调停者模式（Mediator） Java实现
调停者模式调停者模式(Mediator)的定义调停者模式是对象的行为模式.调停者模式包装了一系列对象相互的方式,使得这些对象不必互相明显作用.从而使它们可以较为松散地耦合.当这些对象中的某些对象之 ...
2017-01-01 调停者模式
2017-01-01 调停者模式 Mediator.Colleague.Collaboration |kəˌlæbəˈreɪʃn| Mediator: 调停者模式是对象的行为模式.调停者模式包 ...
设计模式之调停者模式
如有转载,请申明: 转载至 http://blog.csdn.net/qq_35064774/article/details/52096987 1 什么是调停者模式调停者模式包装了一系列对象相互作 ...
《java与模式》中模式总结
转自:http://hi.baidu.com/hannick/blog/item/e820d8947d51a541d1135e54.html 设计模式一览表注:加*的为GoF的23种设计模式. 一. ...
中介者模式调停者 Mediator 行为型设计模式（二十一）
中介者模式(Mediator) 调度.调停意图用一个中介对象(中介者)来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散而且可以独立地改变它们之间的交互. 中介者模式又 ...
[设计模式] 调停者模式（Mediator Pattern）
什么是调停者模式? 调停者模式是一种旨在降低一系列对象之间耦合关系的设计模式.在一个系统中,对象与对象之间是不可避免发生各种通信,共同合作完成特定的功能.我们把这些对象成为同事对象(Collegue) ...
Mediator模式（调停者模式）
模式简介调停者模式用于系统内各模块之间显式调用的解耦,模块之间不进行直接的相互调用,而是通过调停者来间接调用. 模式UML图代码示例(C#) 提示:可在本栏目的资源篇"设计模式代码示例合 ...
设计模式系列-调停者模式-Mediator
调停者模式简介良好设计的应用由轻量级的对象组合而成,这些对象具有特定的职责,符合SOILD 的单一职责原则.然而,这些大量轻量级的对象给应用带来好处的同时也带来了对象之间交互通信的挑战.对象间需要通 ...
《Java设计模式》之调停者模式(Mediator)
调停者模式是对象的行为模式.调停者模式包装了一系列对象相互作用的方式,使得这些对象不必相互明显引用.从而使它们能够较松散地耦合.当这些对象中的某些对象之间的相互作用发生改变时,不会马上影响到其它的一些 ...

mediator模式-调停者模式

mediator模式-调停者模式相关推荐

最新文章

热门文章