Spring框架之中介者模式 (Mediator Pattern)

中介者模式（Mediator Pattern）详解

中介者模式（Mediator Pattern）是一种行为型设计模式，旨在通过引入一个中介者对象来协调各个对象之间的交互，从而避免它们之间直接相互通信。中介者模式的核心思想是将对象之间的复杂相互依赖关系转化为与中介者的交互，通过中介者来控制对象间的通信，这样能够减少对象之间的耦合度，提高系统的可维护性和扩展性。

1. 中介者模式的定义

1.1 什么是中介者模式？

中介者模式是一种设计模式，用来定义一个对象，它封装一系列的对象交互。中介者使得多个对象之间的通信不再直接发生，而是通过中介者对象来进行。这样，各个对象不再直接依赖于其他对象，而是依赖于中介者，从而减少了系统的复杂度并提高了可维护性。

1.2 中介者模式的关键思想

降低类之间的耦合度：通过将对象间的交互交给中介者来处理，减少了类之间的直接依赖关系。
集中管理对象之间的交互：中介者通过管理和控制对象间的消息传递和操作，避免了多方通信带来的复杂性。
增加可扩展性：新增的功能和交互可以通过扩展中介者来实现，不需要修改已有对象的实现。

2. 中介者模式的结构

中介者模式通常由以下几个角色组成：

Mediator（中介者接口） ：定义中介者的接口，用来通过 notify 方法协助对象之间的交互。中介者通过调用对象的方法来协调对象间的通信。
ConcreteMediator（具体中介者类）：实现中介者接口，负责协调各个同事对象之间的交互。
Colleague（同事类）：每个同事类通过中介者与其他同事类进行交互。每个同事对象知道中介者对象，但是不直接与其他同事对象交互。
ConcreteColleague（具体同事类）：继承自同事类，具体实现同事对象的行为。

类图

      +-----------------------+
      |      Mediator         |
      +-----------------------+
      | +notify()             |
      +-----------------------+
               ^
               |
       +-----------------------+
       | ConcreteMediator      |
       +-----------------------+
       | +notify()             |
       +-----------------------+
         /        |       \
        /         |        \
+--------------+  +--------------+  +--------------+
| Colleague A  |  | Colleague B  |  | Colleague C  |
+--------------+  +--------------+  +--------------+
| +send()      |  | +send()      |  | +send()      |
| +receive()   |  | +receive()   |  | +receive()   |
+--------------+  +--------------+  +--------------+

3. 中介者模式的实现

为了更好地理解中介者模式，我们通过一个简单的聊天室示例来实现中介者模式。在这个聊天室中，每个用户都可以发送消息，而消息的发送和接收通过中介者（即聊天室）来协调。用户之间不能直接通信，所有消息的交换通过聊天室（中介者）来处理。

3.1 Java 示例代码

java 复制代码

// 1. Mediator 接口：中介者的接口，声明通知方法
interface Mediator {
    void send(String message, Colleague colleague);
}

// 2. Colleague 类：同事类，定义所有同事类的共同行为
abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void receive(String message);
}

// 3. ConcreteColleague 类 - User A
class UserA extends Colleague {

    public UserA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void receive(String message) {
        System.out.println("User A received: " + message);
    }

    public void send(String message) {
        System.out.println("User A sends: " + message);
        mediator.send(message, this);
    }
}

// 4. ConcreteColleague 类 - User B
class UserB extends Colleague {

    public UserB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void receive(String message) {
        System.out.println("User B received: " + message);
    }

    public void send(String message) {
        System.out.println("User B sends: " + message);
        mediator.send(message, this);
    }
}

// 5. ConcreteMediator 类 - ChatRoom
class ChatRoom implements Mediator {
    private UserA userA;
    private UserB userB;

    public void setUserA(UserA userA) {
        this.userA = userA;
    }

    public void setUserB(UserB userB) {
        this.userB = userB;
    }

    @Override
    public void send(String message, Colleague colleague) {
        if (colleague == userA) {
            userB.receive(message);
        } else if (colleague == userB) {
            userA.receive(message);
        }
    }
}

// 6. 客户端代码
public class MediatorPatternDemo {
    public static void main(String[] args) {
        ChatRoom chatRoom = new ChatRoom();
        
        UserA userA = new UserA(chatRoom);
        UserB userB = new UserB(chatRoom);
        
        chatRoom.setUserA(userA);
        chatRoom.setUserB(userB);
        
        userA.send("Hello from User A!");
        userB.send("Hello from User B!");
    }
}

输出结果：

sql 复制代码

User A sends: Hello from User A!
User B received: Hello from User A!
User B sends: Hello from User B!
User A received: Hello from User B!

4. 中介者模式的应用场景

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

对象之间有复杂的交互关系：当多个对象之间存在相互依赖的关系时，使用中介者模式可以简化系统的设计和维护，避免过多的相互依赖。
多个对象之间需要进行通信，但不希望相互之间过于紧密耦合：通过中介者对象来管理和协调各个对象的交互，减少对象之间的依赖关系。
需要集中管理对象之间的通信：中介者模式可以将多方通信集中管理，特别适合于复杂的业务逻辑场景。
系统中有多个对象协作完成某一任务：如果系统中的多个对象需要合作完成某个任务，中介者模式可以帮助协调它们之间的交互。

5. 中介者模式的优缺点

5.1 优点

减少类之间的耦合：通过中介者对象来管理类之间的通信，避免了多个类之间的直接交互，降低了耦合度。
集中管理：所有的交互逻辑都被封装在中介者类中，容易集中管理和修改。
提高可维护性：当系统需要修改某个交互流程时，只需要修改中介者，而不需要改动每个具体的同事类。
易于扩展 ：新增同事类时，只需要让它实现 Colleague 接口，并将其加入到中介者中即可，不会影响已有的代码。

5.2 缺点

增加系统复杂度：中介者模式引入了一个中介者对象，可能导致系统设计更加复杂，尤其是在有多个同事对象需要交互时。
可能过于集中：当中介者对象变得非常复杂时，它将变成一个"胖中介者"，其中包含了大量的业务逻辑，可能导致维护困难。

6. 中介者模式的实际应用

中介者模式在实际开发中有许多应用，特别是在需要对象间协作但又不希望它们之间过于紧密耦合的场景。以下是一些常见的应用场景：

聊天室系统：如上例所示，聊天室中的每个用户（同事类）通过中介者（聊天室）来进行消息的发送和接收。中介者负责协调消息的转发，避免了直接的点对点通信。
GUI框架：在复杂的用户界面中，多个控件（按钮、输入框等）之间的交互可以通过中介者来管理。例如，在一些MVC框架中，控制器可以作为中介者，协调视图和模型的交互。
航空控制系统：在航空控制系统中，飞机、地面控制中心等多个对象之间需要进行协调和通信。使用中介者模式，可以避免它们之间的直接通信，提高系统的可