解密中介者模式：简化复杂对象交互的设计利器

中介者模式（Mediator Pattern）是一种行为设计模式，通过引入一个中介对象来封装多个对象之间的交互，使各对象无需显式地相互引用，从而实现松耦合。此模式在降低对象耦合度、集中控制交互逻辑方面表现出色，适用于复杂交互场景，如Spring MVC中的DispatcherServlet、Spring中的ApplicationContext、以及Spring Cloud中的Eureka。本文详细介绍了中介者模式的定义、使用场景、主要角色及其Java实现，展示了如何通过中介者模式提高系统的可扩展性和可维护性，是开发者深入理解并应用此设计模式的绝佳指南。

定义

中介者模式（Mediator Pattern）是一种行为设计模式，它使用一个中介对象来封装一系列对象之间的交互，使得这些对象不需要显式地相互引用，从而实现松耦合，提高系统的可扩展性和可维护性。

使用场景

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

1. 复杂对象交互：当多个对象之间存在复杂的交互关系时，可以使用中介者来简化交互逻辑。
2. 松散耦合：希望通过引入一个中介者对象来实现对象之间的松散耦合，避免对象之间的直接引用。
3. 集中控制：需要集中控制多个对象的行为时，可以通过中介者来协调和管理这些对象。
4. 可维护性：系统中对象的交互逻辑频繁变化时，通过中介者模式可以更方便地进行维护和扩展。

主要角色

1. 抽象中介者（Mediator）：定义了中介者的接口，包含了各个同事对象之间交互所需的方法。
2. 具体中介者（Concrete Mediator）：实现了抽象中介者的接口，协调各个同事对象之间的交互关系。
3. 抽象同事类（Colleague）：定义了同事类的接口，包含了具体的业务方法以及需要与其他同事对象交互时的方法。
4. 具体同事类（Concrete Colleague）：实现了抽象同事类的接口，包含了具体的业务方法以及需要与其他同事对象交互时的方法。在需要与其他同事对象通信时，会通过中介者来进行通信。

类图

示例代码

以下是一个简单的聊天系统示例，展示了如何使用中介者模式来管理用户之间的消息传递。

抽象中介者接口

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

具体中介者实现

public class ChatMediatorImpl implements ChatMediator {
    private List<User> users;

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

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

    @Override
    public void sendMessage(String message, User user) {
        for (User u : users) {
            // 排除发送者，避免发送给自己
            if (!u.equals(user)) {
                u.receiveMessage(message);
            }
        }
    }
}

抽象同事类

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 sendMessage(String message);
    public abstract void receiveMessage(String message);

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

具体同事类

public class ChatUser extends User {
    public ChatUser(ChatMediator mediator, String name) {
        super(mediator, name);
    }

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

    @Override
    public void receiveMessage(String message) {
        System.out.println(name + " receives: " + message);
    }
}

客户端代码

public class Client {
    public static void main(String[] args) {
        ChatMediator mediator = new ChatMediatorImpl();
        
        User user1 = new ChatUser(mediator, "张三");
        User user2 = new ChatUser(mediator, "李四");
        User user3 = new ChatUser(mediator, "王五");

        ((ChatMediatorImpl) mediator).addUser(user1);
        ((ChatMediatorImpl) mediator).addUser(user2);
        ((ChatMediatorImpl) mediator).addUser(user3);

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

运行结果：

张三 sends: Hello, everyone!
李四 receives: Hello, everyone!
王五 receives: Hello, everyone!

实际应用中的中介者模式

1. Spring MVC 中的 DispatcherServlet

在Spring MVC中，DispatcherServlet充当了中介者的角色。它接收所有的HTTP请求，并根据请求的URL将请求分发给不同的Controller进行处理。

2. Spring 中的 ApplicationContext

在Spring中，ApplicationContext充当了中介者的角色。它管理了各个Bean之间的依赖关系，当一个Bean需要依赖另一个Bean时，ApplicationContext会负责将依赖注入到Bean中。

3. Spring Cloud 中的 Eureka

在Spring Cloud中，Eureka充当了中介者的角色。它维护了各个微服务之间的注册和发现关系，当一个微服务需要调用另一个微服务时，Eureka会负责将请求转发到目标微服务。

优点与缺点

优点

1. 降低耦合性：通过中介者模式，各个同事对象不再需要直接引用对方，从而降低了耦合性。
2. 集中控制交互：中介者模式将对象的交互逻辑集中到一个中介者对象中，便于维护和修改。
3. 提高可维护性：由于交互逻辑集中在中介者中，当交互逻辑发生变化时，只需要修改中介者即可，其他对象不受影响。

缺点

1. 可能导致中介者复杂化：如果同事对象之间的交互非常复杂，所有的逻辑都集中到中介者中，可能导致中介者变得复杂难以维护。
2. 性能瓶颈：在高并发环境下，中介者可能成为性能瓶颈，因为所有的交互都需要通过中介者来处理。

总结

中介者模式通过引入一个中介对象来封装对象之间的交互，从而实现对象之间的松耦合和集中控制。这种模式在实际开发中有广泛的应用，特别是在需要集中管理和协调多个对象交互的场景下。尽管中介者模式有助于降低系统的复杂度，但在使用时也需要注意避免中介者本身的复杂化问题。