参考链接:
Java设计模式系列之中介者模式
java设计模式之中介者模式
中介者模式用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。
为什么需要调停者
如下图所示,这个示意图中有大量的对象,这些对象既会影响别的对象,又会被别的对象所影响,因此常常叫做同事(Colleague)对象。这些同事对象通 过彼此的相互作用形成系统的行为。从图中可以看出,几乎每一个对象都需要与其他的对象发生相互作用,而这种相互作用表现为一个对象与另一个对象的直接耦 合。这就是过度耦合的系统。
通过引入调停者对象(Mediator),可以将系统的网状结构变成以中介者为中心的星形结构,如下图所示。在这个星形结构中,同事对象不再通过直接的联 系与另一个对象发生相互作用;相反的,它通过调停者对象与另一个对象发生相互作用。调停者对象的存在保证了对象结构上的稳定,也就是说,系统的结构不会因 为新对象的引入造成大量的修改工作。
类图:
调停者模式包括以下角色
抽象调停者(Mediator)角色:
定义出同事对象到调停者对象的接口,其中主要方法是一个(或多个)事件方法。
具体调停者(ConcreteMediator)角色:
实现了抽象调停者所声明的事件方法。具体调停者知晓所有的具体同事类,并负责具体的协调各同事对象的交互关系。
抽象同事类(Colleague)角色:
定义出调停者到同事对象的接口。同事对象只知道调停者而不知道其余的同事对象。
具体同事类(ConcreteColleague)角色:
所有的具体同事类均从抽象同事类继承而来。实现自己的业务,在需要与其他同事通信的时候,就与持有的调停者通信,调停者会负责与其他的同事交互。
案例:
Mediator定义一个抽象的中介者,中介者来维持对象的引用。
package com.madman.base.designMode.Mediator;
/**
* 定义抽象中介者 定义对象之间的依赖关系
* 比如说方法AaffectB表示A改动了会影响B,
* 方法BaffectA类似
* 最常见比如说对象A的值原来类型是String 后来改成了int
* 而对象B的值又来源于A,你想A对象的类型都变了,B对象直接取值还能用嘛,
* 肯定是不能的,必须由中介者转换一下
*/
public abstract class Mediator{
public Colleague A;
public Colleague B;
public Mediator(Colleague a, Colleague b) {
A = a;
B = b;
}
public abstract void AaffectB();
public abstract void BaffectA();
}
ConcreteMediator 具体的中介者,是做事情的人,调停类之间关联关系的人。
package com.madman.base.designMode.Mediator;
/***
*
* 定义具体的中介者,用来执行被影响到事情
* 类中的放AaffectB和BaffectA的具体实现,就是调停类之间的影响。
*
*/
public class ConcreteMediator extends Mediator{
public ConcreteMediator(Colleague a, Colleague b) {
super(a, b);
}
// 处理A对B的影响
@Override
public void AaffectB() {
int number = A.getNumber();
B.setNumber(number * 100);
}
// 处理B对A的影响
@Override
public void BaffectA() {
int number = B.getNumber();
A.setNumber(number / 100);
}
}
Colleague定义具体的对象,也就是同事
package com.madman.base.designMode.Mediator;
/**
* 定义对象类,我们这里叫做同事
* 这里的变量定义了的目的是为了统一标准,因为我们把同事丢进
* 中介者的时候,往往是非显示调用。个性化定制在思考..
*
*/
public abstract class Colleague{
protected int number;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
// 注意这里的参数不再是同事类,而是一个中介者
public abstract void setNumber(int number, Mediator am);
}
ConcreteColleagueA 定义具体的同事A
package com.madman.base.designMode.Mediator;
/**
*
* 定义具体的同事
*/
public class ConcreteColleagueA extends Colleague{
@Override
public void setNumber(int number, Mediator am) {
this.number = number;
am.AaffectB();
}
}
ConcreteColleagueB定义具体的同事B
package com.madman.base.designMode.Mediator;
/**
*
* 定义具体的同事B
*/
public class ConcreteColleagueB extends Colleague{
@Override
public void setNumber(int number, Mediator am) {
this.number = number;
am.BaffectA();
}
}
客户端
package com.madman.base.designMode.Mediator;
public class Client{
public static void main(String[] args) {
Colleague collA = new ConcreteColleagueA();
Colleague collB = new ConcreteColleagueB();
Mediator am = new ConcreteMediator(collA, collB);
System.out.println("==========通过设置A影响B==========");
collA.setNumber(1000, am);
System.out.println("collA的number值为:" + collA.getNumber());
System.out.println("collB的number值为A的10倍:" + collB.getNumber());
System.out.println("==========通过设置B影响A==========");
collB.setNumber(1000, am);
System.out.println("collB的number值为:" + collB.getNumber());
System.out.println("collA的number值为B的0.1倍:" + collA.getNumber());
}
}
结果:
==========通过设置A影响B==========
collA的number值为:1000
collB的number值为A的10倍:100000
==========通过设置B影响A==========
collB的number值为:1000
collA的number值为B的0.1倍:10
调停者模式的优点
松散耦合
调停者模式通过把多个同事对象之间的交互封装到调停者对象里面,从而使得同事对象之间松散耦合,基本上可以做到互补依赖。这样一来,同事对象就可以独立地变化和复用,而不再像以前那样“牵一处而动全身”了。
集中控制交互
多个同事对象的交互,被封装在调停者对象里面集中管理,使得这些交互行为发生变化的时候,只需要修改调停者对象就可以了,当然如果是已经做好的系统,那么就扩展调停者对象,而各个同事类不需要做修改。
多对多变成一对多
没有使用调停者模式的时候,同事对象之间的关系通常是多对多的,引入调停者对象以后,调停者对象和同事对象的关系通常变成双向的一对多,这会让对象的关系更容易理解和实现。
调停者模式的缺点
调停者模式的一个潜在缺点是,过度集中化。如果同事对象的交互非常多,而且比较复杂,当这些复杂性全部集中到调停者的时候,会导致调停者对象变得十分复杂,而且难于管理和维护。