Java中介者模式教程：如何简化对象间的复杂通信

一、引言

在软件开发中，随着系统的复杂性增加，对象间的通信也变得越来越复杂。对象之间的直接交互可能导致系统耦合度过高，难以维护和扩展。中介者模式（Mediator Pattern）是一种行为型设计模式，旨在通过引入一个中介者对象来简化对象间的复杂通信，从而降低系统的耦合度。

本文将深入探讨中介者模式的概念、实现及其在Java中的应用，并通过示例演示如何使用中介者模式来简化对象间的通信。

二、中介者模式概述

2.1 中介者模式定义

中介者模式定义了一个中介者对象，用于封装一系列对象之间的交互。中介者使得对象不需要直接引用彼此，从而使对象间的耦合松散。中介者模式通过将对象间的复杂通信交给中介者对象处理，从而简化了对象间的交互。

2.2 中介者模式的角色

中介者模式主要包括以下角色：

中介者接口（Mediator）：定义一个接口，用于协调对象间的通信。
具体中介者（ConcreteMediator）：实现中介者接口，负责具体的协调和通信逻辑。
同事类（Colleague）：依赖于中介者进行通信的对象类。
具体同事类（ConcreteColleague）：实现具体的同事类，利用中介者进行通信。

2.3 中介者模式的结构

中介者模式的结构如下图所示：

+------------------+
|   Mediator       |
|------------------|
| +notify(colleague) |
+------------------+|v
+---------------------+
| ConcreteMediator    |
|---------------------|
| +colleague1: Colleague  |
| +colleague2: Colleague  |
| +notify(colleague)     |
+---------------------+^||
+---------------------+
| ConcreteColleague1  |
|---------------------|
| +mediator: Mediator |
| +send()             |
| +receive()          |
+---------------------+^|
+---------------------+
| ConcreteColleague2  |
|---------------------|
| +mediator: Mediator |
| +send()             |
| +receive()          |
+---------------------+

三、中介者模式的实现

3.1 中介者接口

中介者接口定义了协调对象间通信的方法。它通常包含一个 notify 方法，用于通知其他同事对象。

public interface Mediator {void notify(Colleague colleague, String message);
}

3.2 具体中介者

具体中介者实现了中介者接口，并负责处理具体的通信逻辑。在这个类中，通常会维护同事对象的引用，并实现协调这些对象的逻辑。

import java.util.HashMap;
import java.util.Map;public class ConcreteMediator implements Mediator {private Map<String, Colleague> colleagues = new HashMap<>();public void addColleague(String name, Colleague colleague) {colleagues.put(name, colleague);colleague.setMediator(this);}@Overridepublic void notify(Colleague colleague, String message) {String colleagueName = colleague.getName();for (Map.Entry<String, Colleague> entry : colleagues.entrySet()) {if (!entry.getKey().equals(colleagueName)) {entry.getValue().receive(message);}}}
}

3.3 同事类接口

同事类接口定义了需要通过中介者进行通信的对象类的基本行为，包括设置中介者的接口。

public interface Colleague {void setMediator(Mediator mediator);void send(String message);void receive(String message);String getName();
}

3.4 具体同事类

具体同事类实现了同事类接口，并通过中介者对象进行通信。

public class ConcreteColleague1 implements Colleague {private Mediator mediator;private String name;public ConcreteColleague1(String name) {this.name = name;}@Overridepublic void setMediator(Mediator mediator) {this.mediator = mediator;}@Overridepublic void send(String message) {System.out.println(name + " sends: " + message);mediator.notify(this, message);}@Overridepublic void receive(String message) {System.out.println(name + " receives: " + message);}@Overridepublic String getName() {return name;}
}public class ConcreteColleague2 implements Colleague {private Mediator mediator;private String name;public ConcreteColleague2(String name) {this.name = name;}@Overridepublic void setMediator(Mediator mediator) {this.mediator = mediator;}@Overridepublic void send(String message) {System.out.println(name + " sends: " + message);mediator.notify(this, message);}@Overridepublic void receive(String message) {System.out.println(name + " receives: " + message);}@Overridepublic String getName() {return name;}
}

3.5 客户端代码

客户端代码创建具体的中介者和同事对象，并通过中介者进行通信。

public class Client {public static void main(String[] args) {ConcreteMediator mediator = new ConcreteMediator();ConcreteColleague1 colleague1 = new ConcreteColleague1("Colleague1");ConcreteColleague2 colleague2 = new ConcreteColleague2("Colleague2");mediator.addColleague("Colleague1", colleague1);mediator.addColleague("Colleague2", colleague2);colleague1.send("Hello from Colleague1");colleague2.send("Hello from Colleague2");}
}

在这个示例中，ConcreteMediator 处理了 ConcreteColleague1 和 ConcreteColleague2 之间的通信。客户端代码通过中介者发送消息，并且消息会被传递到所有其他同事对象。

四、中介者模式的应用场景

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

系统中存在多个对象且它们之间的通信复杂：当对象之间的直接通信导致系统的复杂性增加时，可以使用中介者模式来简化通信。
需要减少对象间的依赖：中介者模式将对象间的通信逻辑集中在一个中介者对象中，减少了对象间的直接依赖。
需要提高系统的灵活性：通过将通信逻辑集中在中介者中，系统的扩展和维护变得更加容易。

五、中介者模式的优缺点

5.1 优点

减少对象间的依赖：中介者模式将对象间的通信逻辑集中在一个中介者对象中，减少了对象间的直接依赖。
简化对象间的通信：中介者模式将对象间的复杂通信交给中介者处理，使得对象之间的交互更加简洁。
提高系统的灵活性：通过将通信逻辑集中在中介者中，可以更容易地修改和扩展系统的功能。

5.2 缺点

中介者对象可能变得复杂：随着系统的复杂性增加，中介者对象可能会变得非常复杂，负责处理大量的通信逻辑。
难以追踪通信过程：由于所有的通信都通过中介者进行，可能会导致通信过程变得不容易追踪和理解。

六、中介者模式的实际案例

6.1 实际案例：聊天系统

在一个聊天系统中，中介者模式可以用于管理用户之间的消息传递。每个用户通过一个中介者（聊天服务器）来发送和接收消息，而不直接与其他用户进行通信。

public interface ChatMediator {void sendMessage(String message, User user);void addUser(User user);
}public class ChatMediatorImpl implements ChatMediator {private List<User> users = new ArrayList<>();@Overridepublic void sendMessage(String message, User user) {for (User u : users) {if (u != user) {u.receive(message);}}}@Overridepublic void addUser(User user) {users.add(user);}
}public 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);
}public class UserImpl extends User {public UserImpl(ChatMediator mediator, String name) {super(mediator, name);}@Overridepublic void send(String message) {System.out.println(name + " sends: " + message);mediator.sendMessage(message, this);}@Overridepublic void receive(String message) {System.out.println(name + " receives: " + message);}
}

在这个示例中，ChatMediatorImpl 作为中介者管理用户之间的消息传递。每个 UserImpl 用户通过中介者发送和接收消息，而不直接与其他用户进行通信。

七、总结

中介者模式是一种强大的设计模式，用于简化对象间的复杂通信。通过引入一个中介者对象，中介者模式降低了系统的耦合度，使得对象之间的交互更加简洁和清晰。在Java中实现中介者模式涉及定义中介者接口、具体中介者、同事类接口和具体同事类，并通过中介者对象协调对象之间的通信。

虽然中介者模式在简化通信和降低耦合度方面具有许多优点，但在实际应用中也需要注意中介者对象的复杂性和通信过程的追踪。通过合理使用中介者模式，可以提高系统的灵活性和可维护性，使得系统设计更加高效和易于扩展。