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

中介者模式讲解

一、概述

中介者模式（Mediator Pattern）是一种行为设计模式，用于减少对象之间的直接交互，降低对象之间的耦合度。通过将对象之间的交互行为集中到一个中介者对象中，使得对象之间不再直接相互引用，而是通过中介者对象进行间接通信。这样可以使得系统的结构更加清晰，易于维护和扩展。

二、模式结构

中介者模式包含以下角色：

1. 中介者（Mediator）：定义各同事对象之间交互的接口，协调各个同事对象的交互行为，降低同事之间的耦合度。

2. 同事类（Colleague）：知道中介者对象的存在，与中介者对象交互，通过中介者对象与其他同事对象通信。

三、实现方式

在实际应用中，中介者模式通常通过定义一个中介者接口和多个实现该接口的同事类来实现。同事类之间不再直接通信，而是通过中介者对象进行交互。

以下是一个简单的Java代码示例：

// 中介者接口
public interface Mediator {
    void send(String message, Colleague colleague);
}

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

// 具体的同事类A
public class ColleagueA implements Colleague {
    private Mediator mediator;

    public ColleagueA(Mediator mediator) {
        this.mediator = mediator;
    }

    public void send(String message) {
        mediator.send(message, this);
    }

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

// 具体的同事类B，类似ColleagueA
// ...

// 具体的中介者实现
public class ConcreteMediator implements Mediator {
    private List<Colleague> colleagues = new ArrayList<>();

    @Override
    public void send(String message, Colleague colleague) {
        for (Colleague c : colleagues) {
            if (!c.equals(colleague)) {
                c.receive(message);
            }
        }
    }

    public void register(Colleague colleague) {
        colleagues.add(colleague);
    }

    public void unregister(Colleague colleague) {
        colleagues.remove(colleague);
    }
}

// 使用示例
public class Client {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        ColleagueA colleagueA = new ColleagueA(mediator);
        ColleagueB colleagueB = new ColleagueB(mediator);

        mediator.register(colleagueA);
        mediator.register(colleagueB);

        colleagueA.send("Hello from A");
    }
}

在这个例子中，ConcreteMediator是中介者的具体实现，它维护了一个同事对象的列表，并实现了send方法来发送消息给除了发送者之外的所有同事。ColleagueA和ColleagueB是同事类的具体实现，它们通过中介者对象来发送和接收消息。

四、优缺点分析

优点：

1. 降低了对象之间的耦合度，使得系统更加灵活，易于扩展和维护。
2. 简化了对象之间的交互，使得代码更加清晰易懂。
3. 集中控制交互，可以在中介者中添加日志记录、异常处理等公共行为。

缺点：

1. 中介者对象可能变得过于复杂，特别是当同事类数量很多时。
2. 如果中介者对象未能正确地转发请求或通知，可能导致系统出错。
3. 同事类过度依赖于中介者对象，中介者对象一旦出问题，整个系统都可能受到影响。

五、应用场景

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

1. 系统中对象之间存在大量的交互，导致代码难以维护和理解。
2. 一个对象需要与多个其他对象进行交互，而这些交互逻辑又比较复杂。
3. 需要集中控制对象之间的交互行为，如添加日志记录、异常处理等。

六、应用案例解读

以聊天室系统为例，中介者模式可以应用于处理用户之间的消息传递。在这个系统中，用户（同事类）之间需要发送和接收消息，但不需要知道彼此的具体实现细节。通过引入一个聊天室中介者（中介者类），用户可以将消息发送给中介者，然后由中介者负责将消息转发给所有其他用户。这样，用户之间的交互就被集中到了中介者对象中，降低了用户之间的耦合度，使得系统更加灵活和易于维护。

六、应用案例解读（续）

以聊天室系统为例，中介者模式的应用可以进一步细化和优化。

首先，我们定义一个ChatRoom作为中介者，负责管理用户（User）之间的消息传递。每个User对象注册到ChatRoom中，并通过ChatRoom发送和接收消息。

// 中介者：聊天室
public class ChatRoom {
    private List<User> users = new ArrayList<>();

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

    public void unregisterUser(User user) {
        users.remove(user);
    }

    public void broadcastMessage(User sender, String message) {
        for (User user : users) {
            if (!user.equals(sender)) {
                user.receiveMessage(sender, message);
            }
        }
    }
}

// 同事类：用户
public class User {
    private String name;
    private ChatRoom chatRoom;

    public User(String name, ChatRoom chatRoom) {
        this.name = name;
        this.chatRoom = chatRoom;
        chatRoom.registerUser(this);
    }

    public void sendMessage(String message) {
        chatRoom.broadcastMessage(this, name + ": " + message);
    }

    public void receiveMessage(User sender, String message) {
        System.out.println(sender.getName() + " says: " + message);
    }

    public String getName() {
        return name;
    }
}

// 使用示例
public class ChatRoomDemo {
    public static void main(String[] args) {
        ChatRoom chatRoom = new ChatRoom();
        User user1 = new User("Alice", chatRoom);
        User user2 = new User("Bob", chatRoom);

        user1.sendMessage("Hello, Bob!");
        user2.sendMessage("Hi, Alice. How are you?");
    }
}

在这个聊天室系统中，ChatRoom中介者管理了所有用户的注册和消息广播。当用户发送消息时，它调用ChatRoom的broadcastMessage方法，该方法遍历所有用户并将消息发送给除了发送者之外的所有用户。这样，用户之间不需要直接相互通信，而是通过中介者进行间接交互。

这种设计使得聊天室系统更加灵活和可扩展。例如，如果需要添加新的功能，如私聊、禁言等，只需在ChatRoom中介者中添加相应的逻辑即可，而不需要修改每个用户对象的代码。同时，通过中介者，还可以方便地添加日志记录、异常处理、权限控制等公共行为。

此外，中介者模式还有助于降低系统的复杂性。在没有中介者的情况下，如果用户数量较多，每个用户都需要与其他用户建立直接的联系，这将导致大量的代码冗余和复杂的交互逻辑。而通过使用中介者模式，可以将这些交互逻辑集中到一个中介者对象中，从而简化了系统的结构。

总结来说，中介者模式在聊天室系统中的应用展示了其降低对象间耦合度、简化交互逻辑以及集中控制交互行为的优点。这种模式在实际开发中非常有用，特别是在处理复杂系统中对象间的大量交互时。