设计模式之中介者模式

        在我们实际开发中，我们经常会遇到多个对象之间互相依赖、互相调用的场景。如果这些对象之间的耦合度太高，不仅会让系统变得难以维护，还会让扩展变得异常困难。此时，中介者模式(Mediatro)就是一种非常实用的设计方案，它可以有效地降低对象之间的耦合度，让系统更加灵活、可维护。

1. 概念

        中介者模式是一种行为型设计模式，它的核心思想是：通过引入一个中介对象，将多个对象之间的交互封装在中介者中，避免对象之间直接引用，从而使它们解藕。

        通俗地说，中介者就像一个“调度员”，各个同事之间不直接沟通，而是通过中介者来协作。

主要包含以下几个角色：

1. Mediator(抽象中介者)：定义同事对象之间通信的接口；

2. ConcreteMediator(具体中介者)：实现协调逻辑，知道所有的同事对象；

3. Colleague(抽象同事类)：定义中介者对象的引用；

4. ConcreteColleague(具体同事类)：通过中介者与其他同事通信。

2. 代码实现

        这里我们使用一个聊天室的例子来演示中介者模式：

首先我们定义一个抽象中介者接口（抽象层就可以当作一个规范即可，不用过多关注）：

public interface ChatMediator {
    void sendMessage(String message, User user);
    void addUser(User user);
}

其次我们来创建一个具体的实现类：

import java.util.ArrayList;
import java.util.List;

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

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

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

接下来我们来编写抽象同事类（同样作为一个抽象层可以不用过多关注）：

public 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);
}

接下来编写同事类的实现：

public class ChatUser extends User {
    public ChatUser(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);
    }
}

外部测试类：

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

        User user1 = new ChatUser(chatRoom, "Alice");
        User user2 = new ChatUser(chatRoom, "Bob");
        User user3 = new ChatUser(chatRoom, "Charlie");

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

        user1.send("大家好！");
        user2.send("Hi Alice！");
    }
}

// 输出结果：
// Alice 发送消息: 大家好！
// Bob 收到消息: 大家好！
// Charlie 收到消息: 大家好！
// Bob 发送消息: Hi Alice！
// Alice 收到消息: Hi Alice！
// Charlie 收到消息: Hi Alice！

其实一些初级开发者会觉得，这样做并没有什么意义，只是加了一层中间层，那么我给大家编写一下不使用中介者模式的代码实现：

import java.util.List;

public class User {
    private String name;
    private List<User> contacts;

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

    public void setContacts(List<User> contacts) {
        this.contacts = contacts;
    }

    public void sendMessage(String message) {
        System.out.println(this.name + " 发送消息: " + message);
        for (User user : contacts) {
            // 不给自己发消息
            if (!user.equals(this)) {
                user.receiveMessage(message);
            }
        }
    }

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

    public String getName() {
        return name;
    }
}

        这里存在的问题就是每个User对象都需要手动维护联系人列表，同时User类不仅负责发送和接收，还要管理用户间的通信逻辑，严重违反了单一职责原则！这样我们的代码耦合度过高，无法灵活扩展、测试也变得困难。

3. 应用场景

• GUI框架中，按钮、输入框等组件之间的通信由窗体中介协调；
• Java Swing的事件驱动机制；
• 微服务架构中的服务编排器(如 AWS Step Functions)；
• Netty中的ChannelPipeline也是一种类似中介者的结构。

4. 总结

        中介者模式是一种非常有用的解藕手段，尤其适用于多个对象之间存在复杂交互的场景。通过引入中介者，我们可以让系统结构更加清晰，逻辑更集中，便于维护和扩展。

一句话来说：当你发现对象之间“你中有我我中有你”的时候，就该考虑中介者模式了。