Java设计模式之中介者模式

概念

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

作用

1.解耦对象间的直接依赖，使系统更松耦合。

2.集中控制交互逻辑，便于维护和扩展。

3.简化对象职责，每个对象只需关注自身行为，无需管理与其他对象的交互。

场景

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

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

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

示例（聊天室）

1.定义中介者接口：声明消息转发方法。

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

2.具体中介者类：实现消息分发逻辑。

// 具体中介者（聊天室）
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);
    }
}

3.同事类（Colleague）：持有中介者引用，通过中介者通信。

// 同事类（用户）
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);
    }
}

4.使用示例

// 使用示例
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!

优缺点

优点

1.降低耦合：对象间不直接依赖，只需依赖中介者。

2.简化维护：交互逻辑集中在中介者，修改不影响同事类。

3.扩展性好：新增同事类只需修改中介者，无需改动其他类。

缺点

1.中介者可能过于复杂：若交互逻辑过多，中介者会膨胀为“上帝类”。

2.性能问题：所有通信经过中介者，可能成为系统瓶颈。

不使用中介者模式的实现

1.用户类

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

2.使用示例

// 使用示例
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.维护困难：对象间关系复杂时，修改可能引发连锁错误。

总结

中介者模式通过集中管理对象交互解决了复杂依赖问题，适用于多对象协作场景。不使用时，对象间直接依赖会导致系统僵化、难以维护。选择中介者模式的权衡点在于中介者的复杂度和系统扩展需求。