设计模式源码git地址:design-pattern-src: 设计模式源码 (gitee.com)

中介者模式其实也就是字面意思,跟你买房的时候往往需要找个中介一样。中介会帮你处理所有事情,你只需要与中介一个人建立联系就可以。那么跟之前学习的代理模式有什么不同之处,代理是完成类和增强类的功能,中介主要是为了解耦

没有中介之前的模式类似于网状结构,不仅你需要跟每个人联系,而且需要他们互相之前也去建立联系,令人头疼的是这种结构往往牵一发而动全身

img

网状结构

有中介之后类似于星状结构,所有人都找中介,大大降低了耦合性

img

星状结构

  1. 定义
  2. 优点
  3. 缺点
  4. 角色
  5. 场景模拟
  6. 总结

定义

中介对象来封装一系列对象之间的交互,使原有对象之间的耦合松散,且可以独立地改变它们之间的交互。是迪米特法则的典型应用。

优点

降低各个对象的耦合性,使系统易于维护与扩展

缺点

每添加对象,就需要在中介处更新,如果对象过多,中介类就会变的臃肿,复杂难以维护

中介出问题,整个程序玩完,道理和卖房中介卷钱跑路一样

角色

抽象中介者(Mediator):中介者的接口,提供了同事对象注册与转发同事对象信息的抽象方法。

具体中介者(ConcreteMediator):实现中介者接口,定义一个 List 来管理同事对象,协调各个同事角色之间的交互关系。

抽象同事类(Colleague):同事类的接口,保存中介者对象,提供同事对象交互的抽象方法,实现所有相互影响的同事类的公共功能。

具体同事类(Concrete Colleague):是抽象同事类的实现者,当需要与其他同事对象交互时,由中介者对象负责后续的交互。

场景模拟

模拟一个发送消息的场景,有三个同事需要互相发消息,这样他们就需要每个人都需要建立关系,现在引入一个中介,发出的消息都由中介去代替他们发送

代码实现

调用端

1
2
3
4
5
6
7
8
9
10
11
12
//创建中介
Mediator mediator = new ConcreteMediator();
//创建三位具体同事
Colleague colleague1 = new ConcreteColleague1();
Colleague colleague2 = new ConcreteColleague2();
Colleague colleague3 = new ConcreteColleague3();
//中介者记录每个同事类
mediator.register(colleague1);
mediator.register(colleague2);
mediator.register(colleague3);
//某个同事发送消息
colleague1.send();

结果输出

1
2
3
4
第一个同事发送消息
中介代替转发中...
第二个同事收到消息
第三个同事收到消息

抽象中介,提供注册和转发方法

1
2
3
4
5
6
public interface Mediator {
//注册
void register(Colleague colleague);
//转发
void relay(Colleague colleague);
}

抽象同事,保存中介对象,提供交互方法

1
2
3
4
5
6
7
8
9
10
public abstract class Colleague {
protected Mediator mediator;
public void setMediator(Mediator mediator) {
this.mediator = mediator;
}
//接收
public abstract void receive();
//发送
public abstract void send();
}

具体中介

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class ConcreteMediator implements Mediator{
private List<Colleague> colleagues = new ArrayList<>();
@Override
public void register(Colleague colleague) {
//传入的对象在集合中没有,则添加,并设置该同事的中介者
if (!colleagues.contains(colleague)) {
colleagues.add(colleague);
//不为每个同事设置中介者,他们就不知道中介者是谁,也就无法建立联系
colleague.setMediator(this);
}
}

@Override
public void relay(Colleague colleague) {
//除了当前同事,对其他同事做出响应
for (Colleague c : colleagues) {
if (!c.equals(colleague)) {
c.receive();
}
}
}
}

具体同事(每个都是一样的,输出略有变化,所有源码请查看git)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ConcreteColleague1 extends  Colleague{
@Override
public void receive() {
System.out.println("第一个同事收到消息");
}

@Override
public void send() {
System.out.println("第一个同事发送消息");
//自己不发送,请求中介者发送
System.out.println("中介代替转发中...");
mediator.relay(this);
}
}

总结

开发中并不常用,生活中常见,实际开发中可应用于对象间存在复杂网状关系时,可以引入中介者来使系统耦合性降低,更易扩展维护