技术成神之路：设计模式（十五）中介者模式

介绍

中介者模式（Mediator Pattern）是一种行为型设计模式，用于减少对象之间的复杂通信和依赖。它通过引入一个中介者对象来封装对象之间的交互，从而使得对象之间不直接相互依赖，而是通过中介者进行通信。

1. 定义

中介者模式将对象之间的通信封装到一个中介者对象中，使各对象不再直接引用彼此，从而减少对象之间的耦合度。

2. 主要作用

• 解耦：降低对象之间的依赖关系。
• 集中控制：所有交互逻辑都集中在中介者中，便于管理。

3. 解决的问题

• 对象之间的复杂交互导致系统难以维护和扩展。
• 对象之间存在大量的直接引用，导致系统耦合度高。
• 需要集中管理对象之间的交互逻辑。

4. 模式原理

包含角色：

1. 中介者（Mediator）：定义一个接口，用于与各同事对象进行通信。
2. 具体中介者（ConcreteMediator）：实现中介者接口，具体协调各同事对象之间的交互。
3. 同事类（Colleague）：各个相互通信的对象，通过中介者与其他同事对象通信。
4. 具体同事类（ConcreteColleague）：实现同事类接口，与中介者进行交互。

UML类图：

示例： 以下是一个简单的聊天室示例

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

// 具体中介者类
class ChatRoom implements ChatMediator {
    private List<User> users;

    public ChatRoom() {
        this.users = new ArrayList<>();
    }

    @Override
    public void addUser(User user) {
        this.users.add(user);
    }
    
    @Override
    public void sendMessage(String message, User user) {
        for (User u : users) {
            // 消息不发送给自己
            if (u != user) {
                u.receive(message);
            }
        }
    }
}

// 同事类
abstract class User {
    protected ChatMediator mediator;
    protected String name;

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

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

// 具体同事类
class ConcreteUser extends User {

    public ConcreteUser(ChatMediator mediator, String name) {
        super(mediator, name);
    }

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

    @Override
    public void receive(String message) {
        System.out.println(this.name + " 接收到消息: " + message);
    }
}

客户端代码：创建了一个ChatRoom（具体中介者）和多个用户，通过中介者来进行消息传递。

public class MediatorPatternDemo {
    public static void main(String[] args) {
        ChatMediator chatMediator = new ChatRoom();

        User user1 = new ConcreteUser(chatMediator, "Alice");
        User user2 = new ConcreteUser(chatMediator, "Bob");
        User user3 = new ConcreteUser(chatMediator, "Charlie");
        User user4 = new ConcreteUser(chatMediator, "Diana");

        chatMediator.addUser(user1);
        chatMediator.addUser(user2);
        chatMediator.addUser(user3);
        chatMediator.addUser(user4);

        user1.send("Hello, everyone!");
    }
}

打印输出

Alice 发送消息: Hello, everyone!
Bob 接收到消息: Hello, everyone!
Charlie 接收到消息: Hello, everyone!
Diana 接收到消息: Hello, everyone!

中介者模式也不难理解，就是起了一个在中间调节作用，比如你去租房，大多数都是去找中介，而你和其他房东在这里都是具体同事类，是不是一下就清晰了好多。

中介者模式又叫调解者模式主要是因为它的核心功能是调解和协调多个对象之间的交互。中介者作为一个中间层，负责管理对象之间的通信，减少它们之间的直接依赖，从而有效地调解各个对象的关系。这种调解作用使得系统更加灵活，便于后期的维护和扩展。

看到这里，有没有发现它和面向切面编程（AOP）很像，在程序中都是起了一个中间者的作用，哈哈，是有一点像，但它们的功能和逻辑差别还是挺大滴，一个是通过中介者解耦对象间的交互，一个是通过切面解耦横切关注点，这里了解下就行。

5. 优缺点

优点：

1. 降低耦合度，便于维护。
2. 中介者集中管理，逻辑清晰。

缺点：

1. 中介者成为了系统的单点故障。
2. 可能导致中介者过于复杂，难以管理。

6. 应用场景

UI组件交互：如在聊天应用中，各个组件（消息、用户列表等）通过中介者管理交互。 中介服务：在微服务架构中，各服务通过一个API网关进行通信。 ...

7. 总结

中介者模式通过引入一个中介者对象，将对象之间的复杂通信逻辑封装起来，从而降低对象之间的耦合度，提高系统的可维护性和可扩展性。虽然中介者模式能显著优化对象间的交互，但也需要注意中介者对象的设计，以避免其逻辑过于复杂和成为性能瓶颈。适用于需要集中管理对象交互逻辑的场景，如GUI应用、聊天室系统和工作流管理系统等。