Java设计模式之中介者模式（Mediator Pattern）

Java设计模式之中介者模式（Mediator Pattern）

引言

在软件开发中，设计模式是解决常见设计问题的一系列最佳实践。中介者模式（Mediator Pattern）是行为型设计模式之一，它的主要目的是减少对象之间的直接相互作用，从而降低它们之间的耦合度。通过引入一个中介者对象来管理对象间的交互，中介者模式让对象之间的通信变得更加简单和灵活。本文将深入探讨中介者模式的概念、结构、优点、缺点、应用场景以及在Java中的实现方式。

中介者模式概述

中介者模式定义了一个中介对象来封装一系列对象之间的交互。这种模式使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。在中介者模式中，中介者负责处理对象间的通信和协作，对象间不再直接交互，而是通过中介者来间接通信。

结构

中介者模式主要包含以下几个角色：

1. 中介者（Mediator）：

   • 定义了对象间交互的接口。
   • 维护一系列对象（同事对象），并协调它们之间的交互。
   • 可以是抽象类或接口，也可以是具体类。

2. 同事类（Colleague）：

   • 持有中介者的引用。
   • 在需要与其他同事通信时，通过中介者来间接通信。
   • 可以是抽象类或接口，也可以是具体类。

优点

1. 降低耦合度：通过中介者对象来管理对象间的交互，减少了对象间的直接引用，降低了系统的耦合度。
2. 易于维护：当系统需要扩展或修改时，只需修改中介者或增加新的中介者类，而无需修改同事类，提高了系统的可维护性。
3. 易于控制交互：中介者可以集中控制同事之间的交互行为，如限制某些交互、添加日志记录等。
4. 提高灵活性：由于对象间的交互由中介者控制，因此可以轻松地改变系统的交互方式，而无需修改大量代码。

缺点

1. 可能产生中介者过度复杂：如果系统中对象间的交互非常复杂，那么中介者对象可能会变得非常复杂和庞大，增加了系统的理解和维护难度。
2. 可能产生中介者依赖：由于所有对象间的交互都通过中介者进行，因此中介者对象可能成为系统的关键节点，一旦中介者出现问题，可能会影响整个系统的运行。

应用场景

1. 对象间存在复杂交互：当多个对象之间存在复杂的交互关系，且这些交互关系经常变化时，可以使用中介者模式来管理这些交互。
2. 系统需要高内聚低耦合：在设计系统时，为了提高系统的内聚性和降低系统的耦合度，可以使用中介者模式来封装对象间的交互细节。
3. 需要集中控制交互行为：如果系统需要集中控制对象间的交互行为，如限制某些交互、添加日志记录等，可以使用中介者模式来实现。

Java实现

下面是一个简单的Java示例，演示了中介者模式的实现。在这个示例中，我们创建了一个聊天室系统，其中包含了多个用户（同事类）和一个聊天室（中介者类）。用户之间通过聊天室进行通信。

// 中介者接口
interface ChatRoom {
    void showMessage(User user, String message);
}

// 具体中介者实现
class ConcreteChatRoom implements ChatRoom {
    private List<User> users = new ArrayList<>();

    @Override
    public void showMessage(User user, String message) {
        for (User u : users) {
            if (!u.equals(user)) {
                u.receive(message);
            }
        }
    }

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

// 同事类接口
interface User {
    void send(String message);
    void receive(String message);
}

// 具体同事类实现
class ConcreteUser implements User {
    private String name;
    private ChatRoom chatRoom;

    public ConcreteUser(String name, ChatRoom chatRoom) {
        this.name = name;
        this.chatRoom = chatRoom;
        chatRoom.addUser(this);
    }

    @Override
    public void send(String message) {
        System.out.println(name + ": " + message);
        chatRoom.showMessage(this, "[" + name + "] " + message);
    }

    @Override
    public void receive(String message) {
        System.out.println(name + " received: " + message);
    }
}

// 测试类
public当然，以下是继续编写的Java代码，展示如何使用中介者模式来创建一个简单的聊天室系统。我们将添加一个测试类来演示如何使用`ConcreteChatRoom`和`ConcreteUser`类。

```java
// 测试类
public class ChatRoomDemo {
    public static void main(String[] args) {
        // 创建中介者对象
        ChatRoom chatRoom = new ConcreteChatRoom();

        // 创建并注册用户
        User user1 = new ConcreteUser("Alice", chatRoom);
        User user2 = new ConcreteUser("Bob", chatRoom);
        User user3 = new ConcreteUser("Charlie", chatRoom);

        // 用户发送消息
        user1.send("Hello everyone!");
        user2.send("Hi Alice, how are you?");
        user3.send("Good to see you all!");

        // 注意：在实际应用中，通常不需要显式地调用receive方法，
        // 因为showMessage方法已经在中介者内部调用了它。
        // 这里只是为了演示User接口的实现而包含receive方法。
    }
}

// 注意：确保ConcreteUser类中的send方法正确调用了chatRoom的showMessage方法，
// 并且receive方法已经按上述方式实现。

// ConcreteUser类（已在上文中定义，这里再次展示以确保完整性）
class ConcreteUser implements User {
    private String name;
    private ChatRoom chatRoom;

    public ConcreteUser(String name, ChatRoom chatRoom) {
        this.name = name;
        this.chatRoom = chatRoom;
        chatRoom.addUser(this); // 注册用户到聊天室
    }

    @Override
    public void send(String message) {
        System.out.println(name + ": " + message); // 显示本地消息
        chatRoom.showMessage(this, "[" + name + "] " + message); // 发送消息到聊天室
    }

    @Override
    public void receive(String message) {
        System.out.println(name + " received: " + message); // 接收并显示消息
    }
}

// ConcreteChatRoom类（已在上文中定义，无需重复）
// ...

// User接口（已在上文中定义，无需重复）
// ...

// ChatRoom接口（已在上文中定义，无需重复）
// ...

在这个示例中，ChatRoomDemo类是我们的测试类，它创建了一个ConcreteChatRoom对象作为中介者，并创建了三个ConcreteUser对象作为同事类（即聊天室的用户）。每个用户都通过调用send方法来发送消息，该方法内部调用了中介者的showMessage方法，将消息广播给除了发送者之外的所有用户。由于showMessage方法内部调用了每个用户的receive方法，因此每个用户都能接收到其他用户发送的消息。

请注意，在实际应用中，receive方法通常不需要由外部代码显式调用，因为中介者已经负责在适当的时候调用它。然而，在这个示例中，我们包含了receive方法的实现，以便更清楚地展示User接口的实现细节。

运行ChatRoomDemo类的main方法将输出类似于以下内容的消息，展示了聊天室中用户之间的交互：

Alice: Hello everyone!
Bob received: [Alice] Hello everyone!
Charlie received: [Alice] Hello everyone!
Bob: Hi Alice, how are you?
Alice received: [Bob] Hi Alice, how are you?
Charlie received: [Bob] Hi Alice, how are you?
Charlie: Good to see you all!
Alice received: [Charlie] Good to see you all!
Bob received: [Charlie] Good to see you all!

这样，我们就完成了一个简单的基于中介者模式的聊天室系统的实现。