Java设计模式之中介者模式怎么实现

1. 中介者模式概述

中介者模式（Mediator Pattern）是一种行为型设计模式，它通过引入一个中介者对象来封装一系列对象之间的交互。中介者模式的主要目的是减少对象之间的直接依赖，使得对象之间的耦合度降低，从而提高系统的可维护性和可扩展性。

1.1 中介者模式的定义

中介者模式定义了一个中介者对象，该对象封装了一组对象之间的交互方式。中介者使得各个对象不需要显式地相互引用，从而使其耦合松散，并且可以独立地改变它们之间的交互。

1.2 中介者模式的适用场景

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

• 当一组对象之间的交互复杂且相互依赖时，可以通过中介者模式来简化交互。
• 当需要在不改变对象结构的情况下，动态地改变对象之间的交互方式时，可以使用中介者模式。
• 当系统中存在多个对象之间的复杂网状结构时，可以通过中介者模式将其转化为星型结构，从而简化系统的复杂性。

2. 中介者模式的结构

中介者模式的结构主要包括以下几个角色：

• Mediator（中介者）：定义了一个接口，用于与各个同事对象进行通信。
• ConcreteMediator（具体中介者）：实现了中介者接口，负责协调各个同事对象之间的交互。
• Colleague（同事类）：定义了一个接口，用于与中介者进行通信。
• ConcreteColleague（具体同事类）：实现了同事类接口，每个具体同事类都知道中介者对象，并通过中介者与其他同事对象进行通信。

2.1 中介者模式的类图

classDiagram
    class Mediator {
        +notify(Colleague colleague): void
    }

    class ConcreteMediator {
        -colleague1: Colleague
        -colleague2: Colleague
        +notify(Colleague colleague): void
    }

    class Colleague {
        -mediator: Mediator
        +Colleague(Mediator mediator)
        +send(): void
        +receive(): void
    }

    class ConcreteColleague1 {
        +send(): void
        +receive(): void
    }

    class ConcreteColleague2 {
        +send(): void
        +receive(): void
    }

    Mediator <|-- ConcreteMediator
    Colleague <|-- ConcreteColleague1
    Colleague <|-- ConcreteColleague2
    ConcreteMediator --> Colleague
    Colleague --> Mediator

2.2 中介者模式的时序图

sequenceDiagram
    participant Colleague1 as ConcreteColleague1
    participant Mediator as ConcreteMediator
    participant Colleague2 as ConcreteColleague2

    Colleague1->>Mediator: send()
    Mediator->>Colleague2: receive()
    Colleague2->>Mediator: send()
    Mediator->>Colleague1: receive()

3. 中介者模式的实现

下面通过一个简单的例子来演示如何在Java中实现中介者模式。

3.1 场景描述

假设我们有一个聊天室系统，其中有多个用户（User）可以通过聊天室（ChatRoom）进行消息的发送和接收。用户之间不直接通信，而是通过聊天室这个中介者来进行消息的传递。

3.2 实现步骤

3.2.1 定义中介者接口

首先，我们定义一个中介者接口 ChatRoomMediator，该接口包含一个 sendMessage 方法，用于发送消息。

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

3.2.2 实现具体中介者

接下来，我们实现一个具体的聊天室中介者 ChatRoom，它负责管理用户之间的消息传递。

import java.util.ArrayList;
import java.util.List;

public class ChatRoom implements ChatRoomMediator {
    private List<User> users;

    public ChatRoom() {
        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 != user) {
                u.receive(message);
            }
        }
    }
}

3.2.3 定义同事类接口

然后，我们定义一个同事类接口 User，该接口包含 send 和 receive 方法，分别用于发送和接收消息。

public abstract class User {
    protected ChatRoomMediator mediator;
    protected String name;

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

    public abstract void send(String message);
    public abstract void receive(String message);
}

3.2.4 实现具体同事类

接下来，我们实现具体的用户类 ChatUser，它继承自 User 类，并实现了 send 和 receive 方法。

public class ChatUser extends User {
    public ChatUser(ChatRoomMediator 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);
    }
}

3.2.5 测试中介者模式

最后，我们编写一个测试类来验证中介者模式的实现。

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

        User user1 = new ChatUser(chatRoom, "Alice");
        User user2 = new ChatUser(chatRoom, "Bob");
        User user3 = new ChatUser(chatRoom, "Charlie");

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

        user1.send("大家好！");
        user2.send("你好，Alice！");
        user3.send("大家好，我是Charlie！");
    }
}

3.3 运行结果

运行上述测试代码，输出结果如下：

Alice 发送消息: 大家好！
Bob 收到消息: 大家好！
Charlie 收到消息: 大家好！
Bob 发送消息: 你好，Alice！
Alice 收到消息: 你好，Alice！
Charlie 收到消息: 你好，Alice！
Charlie 发送消息: 大家好，我是Charlie！
Alice 收到消息: 大家好，我是Charlie！
Bob 收到消息: 大家好，我是Charlie！

4. 中介者模式的优缺点

4.1 优点

• 降低耦合度：中介者模式通过引入中介者对象，将对象之间的复杂交互转化为中介者与各个对象之间的简单交互，从而降低了对象之间的耦合度。
• 简化对象之间的交互：中介者模式将对象之间的交互逻辑集中在中介者中，使得对象之间的交互更加简单和清晰。
• 提高系统的可维护性和可扩展性：由于对象之间的交互逻辑集中在中介者中，因此当需要修改或扩展交互逻辑时，只需修改中介者即可，而不需要修改各个对象。

4.2 缺点

• 中介者对象可能变得复杂：随着系统中对象数量的增加，中介者对象可能会变得非常复杂，因为它需要处理所有对象之间的交互逻辑。
• 中介者对象可能成为系统的瓶颈：由于所有对象之间的交互都需要通过中介者进行，因此中介者对象可能会成为系统的性能瓶颈。

5. 中介者模式的应用实例

中介者模式在实际开发中有广泛的应用，以下是一些常见的应用实例：

5.1 GUI框架中的事件处理

在GUI框架中，用户界面组件（如按钮、文本框等）之间的交互通常通过事件处理机制来实现。中介者模式可以用于管理这些组件之间的交互，从而简化事件处理的逻辑。

5.2 聊天室系统

如前所述，聊天室系统是一个典型的中介者模式应用场景。聊天室作为中介者，负责管理用户之间的消息传递，从而简化了用户之间的直接交互。

5.3 航空交通管制系统

在航空交通管制系统中，飞机之间的通信和协调通常通过地面管制中心（中介者）来进行。地面管制中心负责协调飞机之间的飞行路径，避免碰撞，并确保航班的安全和准时。

6. 总结

中介者模式通过引入中介者对象来封装对象之间的复杂交互，从而降低了对象之间的耦合度，简化了系统的设计和维护。中介者模式适用于对象之间交互复杂且相互依赖的场景，但在实际应用中需要注意中介者对象可能变得复杂和成为系统瓶颈的问题。

通过本文的介绍和示例代码，相信读者已经对中介者模式有了更深入的理解，并能够在实际开发中灵活运用中介者模式来解决复杂对象交互的问题。