深入剖析中介者模式（Mediator Pattern）：提升代码解耦与扩展性-优快云博客

本文链接：https://blog.youkuaiyun.com/sjdgehi/article/details/145874288

深入剖析中介者模式（Mediator Pattern）：提升代码解耦与扩展性

引言

在面向对象设计中，随着系统复杂度的不断增加，类与类之间的相互依赖关系也会变得越来越复杂。在这种情况下，我们很容易遇到所谓的**"依赖地狱"**，即类之间的强耦合关系导致修改一个类时需要修改多个相关类，增加了维护的难度。为了降低这种复杂度并增强代码的可扩展性，**中介者模式（Mediator Pattern）**应运而生。

中介者模式是一种行为型设计模式，它通过引入一个中介对象来解耦多个类之间的直接交互。中介者负责协调各个类之间的通信，从而避免了类之间的直接依赖，极大地提高了系统的灵活性和扩展性。

本文将详细解析中介者模式的定义、结构、实现，并通过实际代码示例阐明其应用场景与优势。

1. 中介者模式概述

1.1 中介者模式的定义

中介者模式（Mediator Pattern）旨在通过引入一个中介对象来封装对象之间的交互，避免对象之间的直接交互。各个对象不再直接通信，而是通过中介者对象进行协调。这种方式有效减少了对象之间的依赖关系，提高了系统的松耦合性。

1.2 中介者模式的结构

中介者模式的主要角色有：

Mediator（中介者接口）：定义一个协调方法，供不同的Colleague对象调用来进行交互。
ConcreteMediator（具体中介者）：实现Mediator接口，负责协调和管理多个Colleague对象的交互。
Colleague（同事类）：每个Colleague类都有一个对Mediator的引用，通过该引用，它们可以与其他同事类进行交互，而无需直接引用其他同事类。
ConcreteColleague（具体同事类）：实现Colleague接口，通常是指具体的对象。

1.3 中介者模式的类图

 +--------------------+         +----------------------+
 |     Mediator       |         |    ConcreteMediator  |
 |--------------------|         |----------------------|
 | +notify()          |<>-------| +notify()            |
 +--------------------+         +----------------------+
                 ^                           ^
                 |                           |
                 |                           |
        +------------------+        +---------------------+
        |   Colleague      |        |  ConcreteColleague  |
        |------------------|        |---------------------|
        | +setMediator()   |<-------| +send()              |
        +------------------+        +---------------------+

Mediator接口定义了notify()方法，用于在ConcreteMediator中协调同事类的交互。
ConcreteMediator实现了Mediator接口，负责具体的协调逻辑。
Colleague类定义了一个setMediator()方法，用来注册中介者对象。
ConcreteColleague类实现了Colleague接口，并通过send()方法向中介者发送请求。

2. 中介者模式的实现

我们通过一个简单的聊天室示例来演示中介者模式的应用。假设我们需要设计一个聊天室，其中多个用户（User）之间能够发送消息，而消息的传递是通过一个ChatRoom来协调的。

2.1 定义中介者接口

// Mediator：中介者接口
public interface ChatRoomMediator {
    void sendMessage(String message, User user);
    void addUser(User user);
}

ChatRoomMediator接口定义了两个方法：

sendMessage()：用于发送消息。
addUser()：用于向聊天室添加用户。

2.2 具体中介者类实现

// ConcreteMediator：聊天室中介者实现
import java.util.ArrayList;
import java.util.List;

public class ChatRoom implements ChatRoomMediator {
    private List<User> users = new ArrayList<>();

    @Override
    public void sendMessage(String message, User user) {
        for (User u : users) {
            // 通过中介者转发消息
            if (u != user) {
                u.receive(message);
            }
        }
    }

    @Override
    public void addUser(User user) {
        users.add(user);
    }
}

ChatRoom实现了ChatRoomMediator接口，负责协调用户之间的消息传递。它内部维护了一个users列表，并实现了sendMessage()和addUser()方法。

2.3 定义同事类（用户）

// Colleague：用户类
public abstract class User {
    protected ChatRoomMediator mediator;
    protected String name;

    public User(String name) {
        this.name = name;
    }

    public void setMediator(ChatRoomMediator mediator) {
        this.mediator = mediator;
    }

    public abstract void send(String message);
    public abstract void receive(String message);
}

User类是一个抽象类，定义了send()和receive()方法。每个User对象都会有一个ChatRoomMediator的引用，通过它来发送和接收消息。

2.4 具体同事类（用户实现）

// ConcreteColleague：具体用户类
public class ConcreteUser extends User {
    
    public ConcreteUser(String name) {
        super(name);
    }

    @Override
    public void send(String message) {
        System.out.println(this.name + " sending message: " + message);
        mediator.sendMessage(message, this);
    }

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

ConcreteUser类实现了User类的send()和receive()方法。在发送消息时，用户通过中介者调用sendMessage()方法来发送消息。

2.5 客户端代码

// Client：聊天室测试
public class ChatRoomClient {
    public static void main(String[] args) {
        // 创建聊天室
        ChatRoomMediator chatRoom = new ChatRoom();

        // 创建用户
        User user1 = new ConcreteUser("John");
        User user2 = new ConcreteUser("Jane");
        User user3 = new ConcreteUser("Doe");

        // 将用户加入聊天室
        user1.setMediator(chatRoom);
        user2.setMediator(chatRoom);
        user3.setMediator(chatRoom);

        chatRoom.addUser(user1);
        chatRoom.addUser(user2);
        chatRoom.addUser(user3);

        // 用户发送消息
        user1.send("Hello everyone!");
        user2.send("Hi John!");
        user3.send("Hello!");
    }
}

2.6 运行结果

John sending message: Hello everyone!
Jane received message: Hello everyone!
Doe received message: Hello everyone!
Jane sending message: Hi John!
John received message: Hi John!
Doe received message: Hi John!
Doe sending message: Hello!
John received message: Hello!
Jane received message: Hello!

2.7 代码解析

ChatRoom：作为中介者，它管理用户的通信。它不直接处理消息的内容，而是负责将消息传递给所有其他用户。
ConcreteUser：作为同事类，ConcreteUser通过调用中介者的sendMessage()方法来发送消息，而不是直接与其他用户通信。
解耦：通过中介者模式，用户之间的通信不再是直接的，而是通过ChatRoom来协调。这样，系统中用户之间的依赖关系被解耦，从而使得系统更容易扩展和维护。

3. 中介者模式的优缺点

3.1 优点

降低耦合：中介者模式减少了类之间的直接依赖关系，促进了类之间的松耦合。
集中化控制：通过中介者集中管理对象间的交互，便于在一个地方管理和修改交互逻辑。
易于扩展：如果需要添加新功能，可以通过修改中介者来扩展系统，而无需修改各个类。

3.2 缺点

中介者过于复杂：当系统变得复杂时，Mediator对象可能变得过于庞大，承担了过多的责任，导致维护难度增加。
潜在的性能问题：由于所有对象的通信都必须通过中介者进行，可能会造成性能瓶颈。

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

GUI事件处理：在复杂的图形用户界面（GUI）中，多个控件（按钮、文本框等）之间可能需要相互配合。中介者模式可以协调这些控件的交互，避免控件之间的直接通信。
聊天系统：如前面示例所示，聊天室中的多个用户通过中介者（聊天室）来协调消息的传递。
工作流引擎：在复杂的工作流引擎中，不同的组件之间需要协同工作。中介者模式可以有效地管理各个组件的交互。