设计模式 - 中介者模式

中介者模式（Mediator Pattern）是一种行为设计模式，它用于减少多个对象和类之间的通信复杂度。中介者模式通过提供一个中介者对象，来处理对象之间的交互，这样就可以使对象之间不需要直接引用彼此，从而实现松耦合。

中介者模式的动机

在许多系统中，类之间存在复杂的交互关系。这些类彼此之间的直接通信会导致系统难以维护和拓展。中介者模式通过引入一个中介者对象，来协调这些对象之间的通信，从而减少了类之间的依赖关系。

例如，在一个聊天系统中，每个用户需要能够与其他用户通信。如果每个用户都需要直接与其他用户进行通信，系统将变得难以管理。使用中介者模式，我们可以通过一个中介者来管理用户之间的通信，用户只需要与中介者交互即可。

中介者模式的结构

中介者模式主要包括以下几个部分：

Mediator（抽象中介者）：定义一个接口用于与各个同事（Colleague）对象进行通信。
ConcreteMediator（具体中介者）：实现抽象中介者接口，协调各个同事对象之间的通信。
Colleague（同事类）：定义与中介者进行交互的接口，并持有中介者的引用。
ConcreteColleague（具体同事类）：实现同事接口，与其他同事对象通过中介者进行交互。

以下是中介者模式的类图：

plaintext 复制代码

+----------------+          +-------------------+
|    Colleague   |          |    Mediator       |
+----------------+          +-------------------+
| -mediator      | <------> | +sendMessage()    |
| +notify()      |          |                   |
+----------------+          +-------------------+
       ^                            ^
       |                            |
       |                            |
+----------------+          +-------------------+
|ConcreteColleague|         |ConcreteMediator   |
+----------------+          +-------------------+
| +operation()   |          | +mediate()        |
+----------------+          +-------------------+

中介者模式的实现

下面是一个使用中介者模式的示例，展示了如何设计一个简单的聊天系统，其中用户通过中介者进行通信。

1. 定义抽象中介者接口

java 复制代码

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

2. 实现具体中介者

java 复制代码

// 具体中介者
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 : this.users) {
            // 消息不应发送给发送者
            if (u != user) {
                u.receive(message);
            }
        }
    }
}

3. 定义抽象同事类

java 复制代码

// 抽象同事类
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);
}

4. 实现具体同事类

java 复制代码

// 具体同事类
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);
    }
}

5. 使用中介者模式

java 复制代码

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

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

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

        user1.send("Hello, everyone!");
        user2.send("Hi, Alice!");
    }
}

输出结果

复制代码

Alice 发送消息: Hello, everyone!
Bob 接收到消息: Hello, everyone!
Charlie 接收到消息: Hello, everyone!
Diana 接收到消息: Hello, everyone!
Bob 发送消息: Hi, Alice!
Alice 接收到消息: Hi, Alice!
Charlie 接收到消息: Hi, Alice!
Diana 接收到消息: Hi, Alice!

中介者模式的优缺点

优点

降低耦合性：通过中介者对象进行通信，各个同事类之间不需要直接引用彼此，减少了类之间的依赖性。
增强可扩展性：添加新的同事类或修改现有同事类时，无需修改其他同事类，只需改变中介者对象即可。
简化对象间的通信：中介者模式集中管理对象间的交互逻辑，使得系统的通信更为清晰和直观。

缺点

可能导致中介者过于复杂：如果系统中对象之间的交互逻辑非常复杂，中介者对象本身可能会变得过于复杂和庞大。
隐藏了类之间的真实关系：由于对象之间的直接通信被中介者替代，类之间的交互变得不那么直观。

适用场景

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

多个对象之间有复杂的交互关系，并且这种交互关系是可以独立于这些对象的逻辑来实现的。
需要动态调整对象之间的交互，可以通过中介者对象来集中管理交互逻辑。
希望通过解耦来简化类之间的交互，提高系统的可维护性和可扩展性。

总结

中介者模式是一种强大的设计模式，可以帮助我们简化对象之间的复杂交互逻辑。在实现中，需要注意中介者对象的复杂度，确保其不会成为系统的性能瓶颈。通过合理设计中介者模式，可以显著提高系统的灵活性和可维护性。