Java设计模式之中介者模式

中介者模式概述

中介者模式（Mediator Pattern）是一种行为型设计模式，用于降低多个对象和类之间的通信复杂性。通过引入一个中介者对象，这些对象无需显式地相互调用，转而通过中介者对象进行交互。这种模式的主要目的是减少对象之间的依赖关系，避免对象间的直接引用，增加系统的灵活性和可扩展性。

中介者模式的结构

中介者模式主要包括以下几个部分：

1. Mediator（抽象中介者）：

   • 定义了同事对象之间通信的接口，通常是一个抽象类或接口。

2. ConcreteMediator（具体中介者）：

   • 实现抽象中介者接口，协调各个同事对象之间的交互行为。持有各个同事对象的引用，处理它们之间的通信和协调。

3. Colleague（同事类）：

   • 是各个参与交互的对象。每个同事对象知道自己的中介者对象，并通过中介者来与其他同事对象通信。

     ┌───────────────────────────────┐
     │          Mediator             │
     │ ───────────────────────────   │
     │ + notify(colleague: Colleague) │
     │ + send(message: String,       │
     │        colleague: Colleague)  │
     └───────────────────────────────┘
                   ▲
                   │
                   │
     ┌───────────────────────────────┐
     │      ConcreteMediator          │
     │ ───────────────────────────    │
     │ - colleague1: Colleague1       │
     │ - colleague2: Colleague2       │
     │ + notify(colleague: Colleague) │
     │ + send(message: String,        │
     │        colleague: Colleague)   │
     └───────────────────────────────┘
         ▲                  ▲
         │                  │
         │                  │
     ┌───────────────────────┐      ┌───────────────────────┐
     │      Colleague1        │      │      Colleague2        │
     │ ─────────────────────  │      │ ─────────────────────  │
     │ - mediator: Mediator   │      │ - mediator: Mediator   │
     │ + send(message: String)│      │ + send(message: String)│
     │ + receive(message:     │      │ + receive(message:     │
     │       String)          │      │       String)          │
     └───────────────────────┘      └───────────────────────┘
     

     中介者模式的实现

     下面是中介者模式的一个简单Java实现示例：

     // 抽象中介者
     interface Mediator {
         void send(String message, Colleague colleague);
     }
     
     // 具体中介者
     class ConcreteMediator implements Mediator {
         private Colleague1 colleague1;
         private Colleague2 colleague2;
     
         public void setColleague1(Colleague1 colleague1) {
             this.colleague1 = colleague1;
         }
     
         public void setColleague2(Colleague2 colleague2) {
             this.colleague2 = colleague2;
         }
     
         @Override
         public void send(String message, Colleague colleague) {
             if (colleague == colleague1) {
                 colleague2.receive(message);
             } else if (colleague == colleague2) {
                 colleague1.receive(message);
             }
         }
     }
     
     // 抽象同事类
     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
     class Colleague1 extends Colleague {
         public Colleague1(Mediator mediator) {
             super(mediator);
         }
     
         @Override
         public void send(String message) {
             System.out.println("Colleague1 sends message: " + message);
             mediator.send(message, this);
         }
     
         @Override
         public void receive(String message) {
             System.out.println("Colleague1 received message: " + message);
         }
     }
     
     // 具体同事类2
     class Colleague2 extends Colleague {
         public Colleague2(Mediator mediator) {
             super(mediator);
         }
     
         @Override
         public void send(String message) {
             System.out.println("Colleague2 sends message: " + message);
             mediator.send(message, this);
         }
     
         @Override
         public void receive(String message) {
             System.out.println("Colleague2 received message: " + message);
         }
     }
     
     // 测试类
     public class MediatorPatternDemo {
         public static void main(String[] args) {
             ConcreteMediator mediator = new ConcreteMediator();
     
             Colleague1 colleague1 = new Colleague1(mediator);
             Colleague2 colleague2 = new Colleague2(mediator);
     
             mediator.setColleague1(colleague1);
             mediator.setColleague2(colleague2);
     
             colleague1.send("Hello from Colleague1");
             colleague2.send("Hello from Colleague2");
         }
     }
     

     中介者模式的优缺点

     优点：

   • 降低耦合性： 中介者模式将对象之间的通信封装在中介者中，减少了对象之间的直接依赖关系。

   • 便于扩展： 新增或修改某个对象时，不需要影响其他对象，只需修改中介者的逻辑即可。

   • 提高可维护性： 复杂的交互行为集中在中介者中，逻辑清晰，便于维护和修改。

   缺点：

   • 中介者复杂性增加： 随着对象的增多和交互逻辑的复杂化，中介者对象可能会变得庞大且难以管理。

   • 可能导致性能问题： 如果中介者处理了过多的逻辑，可能会引发性能瓶颈。

   • 中介者模式适用于以下场景：

   • 对象之间有复杂的交互关系，且依赖关系呈网状： 使用中介者模式可以简化对象之间的交互，避免直接引用。

   • 一个类多次与其他类交互且无法复用交互逻辑： 将这些交互逻辑集中在中介者中，可以避免重复代码。

   • 系统中的类需要进行多对多的通信，且通信逻辑可能发生变化： 通过引入中介者，可以灵活地调整对象之间的通信方式。

   • 通过使用中介者模式，可以使系统更加模块化和灵活，但也要注意控制中介者的复杂度，以避免反而增加系统的维护难度。

     适用场景