中介模式(Mediator Pattern)

2025-05-10

behavioral, mediator

用来降低多个对象和类之前的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之前的通信，并支持松耦合，使代码易于维护。

核心思想

  • 将对象之前的交互逻辑集中到一个中介者对象中处理。
  • 对象之前不再相互引用，而是通过中介者进行通信。

角色组成

角色 描述
Mediator(抽象中介者) 定义同事对象之间的通信接口。
ConcreteMediator(具体中介者) 实现具体的交互逻辑，并协调同事对象。
Colleague(抽象同事类) 持有中介者对象，定义与业务相关的方法。
ConcreteColleauge(具体同事类) 实现具体的业务方法，并通过中介者与其他同事交互。

代码示例

  1. 抽象中介者
1
2
3
public interface Mediator {
  void send(String message, Colleague colleague);
}
  1. 具体中介者
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
pubic class ConcreteMediator implements Mediator {
  private Colleague colleagueA;
  private Colleague colleagueB;
  
  public void setColleagueA(Colleague colleagueA) {
    this.colleagueA = colleagueA;
  }
  
  public void setColleagueB(Colleague colleagueB) {
    this.colleagueB = colleagueB;
  }
  
  @Override
  public void send(String message, Colleague colleague) {
    if (colleague == colleagueA) {
      colleagueB.receive(message);
    } else {
      colleagueA.receive(message);
    }
  }
}
  1. 抽象同事类
1
2
3
4
5
6
7
8
9
10
public abstract class Colleague {
  protected Mediator mediator;
  
  public Colleague(Mediator mediator) {
    this.mediator = mediator;
  }
  
  public abstract void send(String message);
  public abstract void receive(String message);
}
  1. 具体同事类
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
public class ConcreteColleagueA extends Colleague {
  public ConcreteColleagueA(Mediator mediator) {
    super(mediator);
  }
  
  @Override
  public void send(String message) {
    mediator.send(message, this);
  }
  
  @Override
  public void receive(String message);
}
public class ConcreteColleagueB extends Colleague {
  public ConcreteColleagueB(Mediator mediator) {
    super(mediator);
  }
  
  @Override
  public void send(String message) {
    mediator.send(message, this);
  }
  
  @Override
  public void receive(String message);
}


  1. 使用示例
1
2
3
4
5
6
7
8
9
10
val mediator = new ConcreteMediator();

val colleagueA = ConcreteColleagueA(mediator);
val colleagueB = ConcreteColleagueB(mediator):

mediator.setColleagueA(colleagueA);
mediator.setColleagueB(colleagueB);

colleagueA.send("Hello from A!");
colleagueB.send("Hi from B!");

总结

中介者模式通过引入中介者对象，将对象之间的复杂交互解耦，使系统清晰和易于维护。它适用于对象之间交互复杂、需要统一管理通信的场景。