Java设计模式之中介者模式

中介者模式（Mediator Pattern）

1. 概述

中介者模式是一种行为型设计模式，它定义了一个中介对象来封装对象之间的交互，从而使对象之间不需要直接引用。通过引入中介者，中介者负责协调对象之间的通信，使得对象之间的耦合度降低，且可以独立地变化和复用。

2. 适用场景

• 系统中对象之间存在复杂的交互，导致对象之间的依赖关系复杂且混乱。
• 希望通过一个中介者来集中控制多个对象的交互行为。
• 需要解耦多个对象的关系，避免对象之间的紧密耦合。

3. 结构

• Mediator（中介者接口）：定义了同事对象（Colleague）之间通信的接口。
• ConcreteMediator（具体中介者）：实现中介者接口，负责协调各同事对象之间的交互。
• Colleague（同事类）：各同事类通过中介者进行交互，彼此之间不直接通信。

4. 示例代码

假设我们要实现一个简单的聊天室（Chat Room），多个用户可以通过聊天室进行通信。使用中介者模式，聊天室就是中介者，用户则是同事类。

// 定义中介者接口
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);
    }
}

// 测试代码
public class MediatorPatternDemo {
    public static void main(String[] args) {
        ChatMediator chatRoom = new ChatRoom();

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

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

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

5. 运行结果

当 Alice 发送消息 “Hello everyone!” 时，其他用户（Bob, Charlie, David）都会接收到这条消息。

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

6. 分析

• 解耦对象：用户之间不直接通信，而是通过聊天室（中介者）来完成通信，避免了用户之间的耦合。
• 集中控制：所有的通信逻辑都集中在 ChatRoom 类中，使得系统结构更加清晰，便于管理和扩展。
• 灵活性：如果需要更改通信逻辑或添加新的功能，只需修改或扩展中介者即可，而无需修改每个用户类。

通过中介者模式，可以使系统的设计更加灵活，降低了对象之间的依赖性，从而使得系统更易于维护和扩展。