Java设计模式-中介者模式（20）

中介者模式（Mediator Pattern）是行为设计模式之一，它旨在通过定义一个中介对象来封装多个对象之间的交互关系，从而使这些对象不必相互引用，从而降低系统的耦合度并提高可维护性。在Java中实现中介者模式时，主要遵循以下步骤和组件：

核心概念
中介者（Mediator）：定义一个接口，用于同事对象之间的通信。它负责协调各同事对象的行为，将复杂的网状结构转换为星形结构，中介者自身则位于这个星形结构的中心。

同事（Colleague）：每个同事都知道中介者并且与其通信，而不是直接与其他同事通信。每个同事都有一个对中介者的引用，当需要与其他同事交互时，会通过中介者来完成。

中介者模式包含以下主要角色。

1. 抽象中介者（Mediator） 角色： 它是中介者的接口，提供了同事对象注册与转发同事对象

信息的抽象方法。

1. 具体中介者（ConcreteMediator）角色： 实现中介者接口，定义一个 List 来管理同事对

象，协调各个同事角色之间的交互关系， 因此它依赖于同事角色。

1. 抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交

互的抽象方法， 实现所有相互影响的同事类的公共功能。

1. 具体同事类（Concrete Colleague）角色： 是抽象同事类的实现者，当需要与其他同事对

象交互时， 由中介者对象负责后续的交互。

实现步骤
定义中介者接口：定义一个接口或抽象类，声明同事对象可能需要的通信方法。

public interface Mediator {
void sendMessage(String message, Colleague colleague);
}
实现具体中介者：实现中介者接口，处理同事对象之间的具体通信逻辑。

public class ConcreteMediator implements Mediator {
private ConcreteColleague1 colleague1;
private ConcreteColleague2 colleague2;

public void setColleague1(ConcreteColleague1 colleague1) {
    this.colleague1 = colleague1;
}

public void setColleague2(ConcreteColleague2 colleague2) {
    this.colleague2 = colleague2;
}

@Override
public void sendMessage(String message, Colleague colleague) {
    if (colleague == colleague1) {
        colleague2.receive(message);
    } else {
        colleague1.receive(message);
    }
}

}

定义同事接口：定义一个同事接口或抽象类，声明接收消息的方法。

public abstract class Colleague {
protected Mediator mediator;

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

abstract void receive(String message);

}
实现具体同事类：具体同事类实现同事接口，通过中介者来通信。

public class ConcreteColleague1 extends Colleague {
public ConcreteColleague1(Mediator mediator) {
super(mediator);
}

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

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

}

public class ConcreteColleague2 extends Colleague {
public ConcreteColleague2(Mediator mediator) {
super(mediator);
}

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

}

应用示例
在实际应用中，例如在图形用户界面（GUI）设计中，按钮、文本框等组件可能需要相互通信来协调动作，这时就可以使用中介者模式来集中处理这些组件间的交互，而不是让每个组件直接引用其他组件。这使得组件可以独立变化，系统也更容易扩展和维护。

模式的优缺点及适用场景
优点：

降低耦合度：通过中介者，同事对象之间无需直接引用对方，减少了对象间的直接依赖，从而降低了系统的耦合性，提高了模块的独立性。

简化对象间通信：中介者封装了复杂的交互逻辑，使得单一对象不再需要了解复杂的交互细节，简化了对象的设计，使系统更易于理解、维护和扩展。

增强可重用性和灵活性：中介者模式使得改变对象间的交互变得容易，只需调整中介者的逻辑即可应对新的交互需求，增强了系统的灵活性和可重用性。

缺点：

中介者可能会变得过于复杂：如果系统中同事类众多，且它们之间的交互非常复杂，中介者可能会变得庞大而难以管理，这反而会增加系统的复杂度。

过度集中化的问题：将所有交互逻辑集中到中介者中，可能导致中介者成为系统的瓶颈，尤其是在需要频繁改动交互规则的情况下，维护成本会相应增加。

适用场景：

多对多复杂的交互场景：当系统中存在多对多交互关系，且这种交互关系随时间可能发生变化时，中介者模式能有效解耦对象，便于管理。

用户界面构建：在GUI设计中，各种UI组件（如按钮、文本框）之间的交互可以通过中介者来集中处理，简化组件设计，提高可维护性。

事件管理：在事件驱动的系统中，通过中介者统一管理事件的发布和订阅，可以有效地协调不同组件间的事件处理逻辑。

分布式系统协调：在分布式系统中，不同的服务或组件间需要协调工作时，中介者模式可用于设计协调服务，简化跨服务的通信逻辑。

示例代码应用深化
继续以GUI设计为例，展示中介者模式如何在具体场景中应用：

假设我们正在设计一个简易聊天室界面，其中包含“用户列表”、“聊天窗口”和“发送按钮”三个组件。每个组件都需要在特定条件下与其他组件进行交互，例如点击发送按钮后，需要更新聊天窗口并通知用户列表。使用中介者模式，我们可以这样设计：

// 具体中介者：ChatRoomMediator
public class ChatRoomMediator implements Mediator {
private UserListComponent userList;
private ChatWindowComponent chatWindow;
private SendButtonComponent sendButton;

// 设置组件
public void setUserListComponent(UserListComponent userList) { ... }
public void setChatWindowComponent(ChatWindowComponent chatWindow) { ... }
public void setSendButtonComponent(SendButtonComponent sendButton) { ... }

// 实现消息传递
@Override
public void sendMessage(String message, Colleague colleague) {
    if (colleague == sendButton) {
        String userSelection = userList.getSelectedUser();
        if (userSelection != null) {
            chatWindow.addMessage("You: " + message, userSelection);
        }
    }
    // 可根据需要扩展更多交互逻辑
}

}

// 具体同事类示例：SendButtonComponent
public class SendButtonComponent extends Colleague {
public SendButtonComponent(Mediator mediator) {
super(mediator);
}

public void onClick() {
    mediator.sendMessage(getMessageFromInput(), this);
}
// 省略其他实现细节...

}

在这个例子中，ChatRoomMediator作为中介者，负责协调UserListComponent、ChatWindowComponent和SendButtonComponent之间的交互，而这些组件本身并不直接相互依赖，而是通过中介者进行通信。这样，当有新的交互需求或者组件需要调整时，只需要修改中介者的逻辑，大大降低了系统的耦合度和修改成本。

为了进一步深化中介者模式在聊天室界面设计中的应用，我们来完善其余两个同事类——UserListComponent和ChatWindowComponent的实现，以及展示它们如何通过中介者进行有效的沟通。

具体同事类：UserListComponent
用户列表组件需要能够响应用户的点击操作，并通过中介者通知其他组件这一变化，比如当用户从列表中选择了一个对话对象时，可能需要更新聊天窗口的显示状态。

public class UserListComponent extends Colleague {
private List users;
private String selectedUser;

public UserListComponent(Mediator mediator, List<String> users) {
    super(mediator);
    this.users = users;
}

public void selectUser(String user) {
    this.selectedUser = user;
    mediator.sendMessage("User selected: " + user, this);
}

public String getSelectedUser() {
    return selectedUser;
}

@Override
void receive(String message) {
    // 在这个场景中，用户列表通常不需要直接接收其他组件的消息
}

}

具体同事类：ChatWindowComponent
聊天窗口组件负责显示聊天记录，并在收到新消息时进行更新。它通过中介者接收来自发送按钮的发送消息请求以及可能的其他交互指令。

public class ChatWindowComponent extends Colleague {
private Map> chatHistory;

public ChatWindowComponent(Mediator mediator) {
    super(mediator);
    this.chatHistory = new HashMap<>();
}

public void addMessage(String message, String recipient) {
    chatHistory.computeIfAbsent(recipient, k -> new ArrayList<>()).add(message);
    displayMessage(message, recipient); // 假设这是显示消息的方法
}

private void displayMessage(String message, String recipient) {
    System.out.println("To " + recipient + ": " + message);
}

@Override
void receive(String message) {
    // 假设这里处理从用户列表接收到的用户选择变更消息，但在这个简化示例中，这部分逻辑可能不适用
}

}

整体协作示例
现在，让我们简要概述这些组件是如何通过中介者协作的：

初始化阶段：创建中介者ChatRoomMediator实例，并为它设置所有同事组件（用户列表、聊天窗口、发送按钮）。同事组件在构造时也会传入中介者实例，确保它们都能通过中介者进行通信。

用户交互：当用户在UserListComponent中选择了一个用户，该组件通过中介者发送选择信息。中介者接收到信息后，可以选择性地通知其他组件，比如更新聊天窗口的预览状态。

消息发送：点击SendButtonComponent时，它通过中介者告知要发送的消息内容。中介者随后根据当前选中的用户（从UserListComponent获取），在ChatWindowComponent中添加新消息，并可能更新用户列表的状态（尽管在这个简化的例子中未体现）。

结论
中介者模式简化了对象之间的交互，减少了对象间的耦合，使得系统易于修改和扩展。在设计中合理运用此模式，可以有效管理对象间的复杂关系，特别是在需要协调多个对象行为的场景下。

通过这种方式，中介者模式不仅清晰地分离了各个组件的职责，还提供了高度灵活的通信机制，使得在不影响现有组件的情况下，未来可以轻松添加更多功能或调整交互逻辑，从而极大地提升了系统的可维护性和扩展性。