中介者模式

概念

中介者模式（Mediator Pattern）是一种行为型设计模式，通过引入一个中介对象来封装一系列对象之间的交互，从而减少对象间的直接耦合。其核心思想是将多对多的复杂依赖关系转化为一对多的集中管理，使对象间不再直接通信，而是通过中介者进行协调。

作用

1.解耦对象间的直接依赖，降低系统耦合度。

2.集中管理交互逻辑，提升代码可维护性和扩展性。

3.简化对象职责，使每个对象仅需关注自身行为，无需处理与其他对象的直接通信。

场景

1.对象间存在复杂的网状引用关系，导致系统难以维护。

2.多个对象需要协作，但直接依赖会导致代码冗余或复用困难。

3.需要统一管理交互逻辑，例如聊天系统、GUI组件交互、任务调度等场景。

举例

使用中介者模式的聊天室示例：

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

// 具体中介者类（聊天室）
import java.util.ArrayList;
import java.util.List;

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

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

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

// 同事类（用户）抽象基类
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 msg);
    public abstract void receive(String msg);
}

// 具体用户实现
class ChatUser extends User {
    public ChatUser(ChatMediator mediator, String name) {
        super(mediator, name);
        mediator.addUser(this); // 注册到中介者
    }

    @Override
    public void send(String msg) {
        System.out.println(name + " 发送消息: " + msg);
        mediator.sendMessage(msg, this); // 通过中介者发送
    }

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

// 使用示例
public class MediatorDemo {
    public static void main(String[] args) {
        ChatMediator chatRoom = new ChatRoom();
        User alice = new ChatUser(chatRoom, "Alice");
        User bob = new ChatUser(chatRoom, "Bob");

        alice.send("Hi, Bob!"); // Alice 发送消息，Bob 接收
    }
}

控制台输出：

Alice 发送消息: Hi, Bob!
Bob 收到消息: Hi, Bob!

反例

不使用中介者模式的直接依赖实现：

// 用户类（直接持有其他用户引用）
import java.util.ArrayList;
import java.util.List;

class User {
    private String name;
    private List<User> users = new ArrayList<>();

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

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

    public void sendDirect(String msg) {
        System.out.println(name + " 发送消息: " + msg);
        for (User user : users) {
            user.receiveDirect(msg);
        }
    }

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

// 使用示例
public class WithoutMediatorDemo {
    public static void main(String[] args) {
        User alice = new User("Alice");
        User bob = new User("Bob");

        // 必须显式建立直接依赖
        alice.addContact(bob);
        bob.addContact(alice);

        alice.sendDirect("Hi, Bob!");
    }
}

控制台输出：

Alice 发送消息: Hi, Bob!
Bob 收到消息: Hi, Bob!

反例问题分析：

1.高耦合：每个用户需手动维护其他用户的引用，新增用户时需修改所有相关代码。

2.难以扩展：添加新用户时，必须逐个更新现有对象的依赖关系。

3.重复代码：交互逻辑分散在各对象中，导致冗余。

4.维护困难：对象间关系复杂时，修改可能引发连锁错误。

原理

中介者模式通过引入中介对象，将原本分散在多个对象中的交互逻辑集中管理。同事类（Colleague）仅保留与中介者的关联，通过调用中介者的方法完成与其他同事的通信，从而避免直接依赖。这种机制将多对多的复杂关系转化为一对多的集中控制，降低了系统的耦合度。

缺点

1.中介者可能膨胀为“上帝类”：若交互逻辑过于复杂，中介者会承担过多职责，导致代码难以维护。

2.性能瓶颈：所有通信需经过中介者，高频交互场景下可能影响系统性能。

总结

中介者模式通过集中管理对象交互，有效解决了多对象协作时的复杂依赖问题，适用于聊天系统、GUI组件等需要统一控制交互的场景。其核心优势在于降低耦合、提升可维护性，但需权衡中介者的复杂度与系统扩展需求。不使用该模式时，对象间直接依赖会导致系统僵化，而合理应用中介者模式可显著提升代码的可扩展性和可维护性。