alexpdh's blog

Java设计模式(二十二):中介者模式

中介者模式(Mediator Pattern)

中介者模式(Mediator Pattern):属于对象的行为模式。又叫调停者模式,用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变他们之间的交互。


中介者模式UML图

mediator-pattern.jpg


中介者模式涉及的角色

抽象中介者(Mediator)角色:定义了同事对象到中介者对象的接口。
具体中介者(ConcreteMediator)角色:实现抽象类的方法,它需要知道所有具体同事类,并从具体同事接收消息,向具体同事对象发出命令。
抽象同事(Colleague)角色:定义出中介者到同事对象的接口。同事对象只知道中介者而不知道其余的同事对象。
具体同事(ConcreteColleague)角色:每个具体同事只知道自己的行为,而不了解其它同事类的情况,但它们却都认识中介者对象。


示例代码

抽象中介者类 Mediator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.example.mediatorPattern;
/**
* 中介者模式:中介者抽象类
*
* @author pengdh
* @date: 2017-08-13 2:46
*/
public abstract class Mediator {
/**
* 同事对象在自身发生改变的时候来通知中介者方法
* 让中介者来负责与其它同事对象的交互
*
* @param messge 消息
* @param colleague 同事对象
*/
protected abstract void send(String messge, Colleague colleague);
}

抽象同事类 Colleague

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.example.mediatorPattern;
/**
* 中介者模式:抽象同事类
*
* @author pengdh
* @date: 2017-08-13 2:48
*/
public abstract class Colleague {
// 持有一个中介者对象
protected Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
}

具体同事类A ConcreteColleagueA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.example.mediatorPattern;
/**
* 中介者模式:具体同事类A
*
* @author pengdh
* @date: 2017-08-13 2:52
*/
public class ConcreteColleagueA extends Colleague {
public ConcreteColleagueA(Mediator mediator) {
super(mediator);
}
/**
* 发送消息
*
* @param messge
*/
public void send(String messge) {
mediator.send(messge,this);
}
/**
* 获取消息
*
* @param message
*/
public void getMessage(String message) {
System.out.println("同事A得到消息:" + message);
}
}

具体同事类B ConcreteColleagueB

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.example.mediatorPattern;
/**
* 中介者模式:具体同事类B
*
* @author pengdh
* @date: 2017-08-13 3:04
*/
public class ConcreteColleagueB extends Colleague {
public ConcreteColleagueB(Mediator mediator) {
super(mediator);
}
/**
* 发送消息
*
* @param messge
*/
public void send(String messge) {
mediator.send(messge,this);
}
/**
* 获取消息
*
* @param message
*/
public void getMessage(String message) {
System.out.println("同事B得到消息:" + message);
}
}

客户端测试类 MediatorPatternTest

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.example.mediatorPattern;
/**
* 中介者模式:客户端测试类
*
* @author pengdh
* @date: 2017-08-13 3:14
*/
public class MediatorPatternTest {
public static void main(String[] args) {
ConcreteMediator mediator = new ConcreteMediator();
// 使同事对象持有中介者对象
ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
// 使中介者持有并维护两个同事类
mediator.setColleagueA(colleagueA);
mediator.setColleagueB(colleagueB);
colleagueA.send("吃过饭了吗?");
colleagueB.send("没有呢");
}
}

中介者模式的优点

  • 松散耦合

中介者模式通过把多个同事对象之间的交互封装到中介者对象里面,从而使得同事对象之间松散耦合,基本上可以做到互补依赖。这样一来,同事对象就可以独立地变化和复用,而不再像以前那样“牵一处而动全身”了。

  • 集中控制交互

多个同事对象的交互,被封装在中介者对象里面集中管理,使得这些交互行为发生变化的时候,只需要修改中介者对象就可以了,当然如果是已经做好的系统,那么就扩展中介者对象,而各个同事类不需要做修改。

  • 多对多变成一对多

没有使用中介者模式的时候,同事对象之间的关系通常是多对多的,引入中介者对象以后,中介者对象和同事对象的关系通常变成双向的一对多,这会让对象的关系更容易理解和实现。


中介者模式的缺点

调停者模式的一个潜在缺点是,过度集中化。如果同事对象的交互非常多,而且比较复杂,当这些复杂性全部集中到调停者的时候,会导致调停者对象变得十分复杂,而且难于管理和维护。


参考文献

alexpdh wechat
欢迎扫一扫关注 程序猿pdh 公众号!