程序员必知！中介者模式的实战应用与案例分析
source link: https://blog.51cto.com/bytegood/9200226
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
程序员必知！中介者模式的实战应用与案例分析
精选 原创
中介者模式通过引入中介类降低对象间耦合度，在电商平台中，卖家、买家、物流公司和支付平台原本需复杂交互，在引入“交易中介”类后，各角色只需与中介交互，由中介协调各方操作，从而简化了交互流程，降低了类间依赖，使系统更灵活可维护。
中介者模式主要用于减少类之间的耦合，它用一个中介类来封装一系列对象间的交互，使这些对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
举一个业务中的例子来说明，假设有一个电商平台，其中有卖家、买家、物流公司和支付平台四个角色，在没有中介者的情况下，这四个角色之间可能需要进行复杂的交互，比如卖家要直接联系物流公司发货，买家要直接联系支付平台进行支付等，这样的设计会导致类之间的耦合度很高，一旦某个角色发生变化，可能会影响到其他角色。
而引入中介者模式后，可以设计一个电商平台的“交易中介”类，这个类中介了卖家、买家、物流公司和支付平台之间的所有交互，卖家只需要将商品信息和买家信息提交给交易中介，交易中介会负责联系物流公司进行发货，并通知买家进行支付，买家支付完成后，交易中介会通知卖家和物流公司更新订单状态，这样，卖家、买家、物流公司和支付平台之间的耦合度就大大降低了，每个角色只需要和交易中介进行交互，而不需要直接和其他角色进行交互。
在这个场景中中，交易中介类就起到了中介者的作用，它将一系列对象间的交互封装起来，使这些对象之间的耦合度降低，提高了系统的灵活性和可维护性。
下面是一个未使用中介者模式的反例代码，假如，有一个聊天应用的简单模型，其中包括User（用户）和GroupChat（群聊）类，每个User对象都直接与其他User对象通信，如下代码演示：
public class User {
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void sendMessage(User receiver, String message) {
System.out.println(name + " sends a message to " + receiver.getName() + ": " + message);
}
}
public class GroupChat {
private List<User> users = new ArrayList<>();
public void addUser(User user) {
users.add(user);
}
public void notifyAllUsers(String message) {
for (User user : users) {
for (User otherUser : users) {
if (!user.equals(otherUser)) {
user.sendMessage(otherUser, message);
}
}
}
}
}
public class Client {
public static void main(String[] args) {
User alice = new User("Alice");
User bob = new User("Bob");
User charlie = new User("Charlie");
GroupChat chat = new GroupChat();
chat.addUser(alice);
chat.addUser(bob);
chat.addUser(charlie);
alice.sendMessage(bob, "Hi Bob, how are you?");
alice.sendMessage(charlie, "Hi Charlie, what's up?");
chat.notifyAllUsers("Everyone, there will be a maintenance tonight.");
}
}
输出结果，如下：
Alice sends a message to Bob: Hi Bob, how are you?
Alice sends a message to Charlie: Hi Charlie, what's up?
Alice sends a message to Bob: Everyone, there will be a maintenance tonight.
Alice sends a message to Charlie: Everyone, there will be a maintenance tonight.
Bob sends a message to Alice: Everyone, there will be a maintenance tonight.
Bob sends a message to Charlie: Everyone, there will be a maintenance tonight.
Charlie sends a message to Alice: Everyone, there will be a maintenance tonight.
Charlie sends a message to Bob: Everyone, there will be a maintenance tonight.
在这个反例中，User类直接持有对其他User对象的引用，并直接调用其方法，这导致了类之间的紧密耦合，因为User类需要知道如何与其他User对象通信，此外，GroupChat类虽然被设计出来，但并没有起到中介消息的作用，实际上，当notifyAllUsers方法被调用时，每个用户都会向其他每个用户发送消息，导致了重复的消息和不必要的复杂性。
下面是一个使用中介者模式的正例代码，在这个例子中，有一个聊天应用的模型，包括User（用户）和ChatMediator（聊天中介）类，ChatMediator类作为中介者，封装了用户之间的通信逻辑，使得用户之间不需要直接相互引用，如下代码：
import java.util.*;
// User.java
public class User {
private String name;
private ChatMediator chatMediator;
public User(String name, ChatMediator chatMediator) {
this.name = name;
this.chatMediator = chatMediator;
}
public String getName() {
return name;
}
// 用户通过中介者发送消息
public void sendMessage(String receiverName, String message) {
chatMediator.relayMessage(this, receiverName, message);
}
}
// ChatMediator.java
public class ChatMediator {
private Map<String, User> users = new HashMap<>();
public void registerUser(User user) {
users.put(user.getName(), user);
}
// 中介者负责将消息传递给指定的接收者
public void relayMessage(User sender, String receiverName, String message) {
User receiver = users.get(receiverName);
if (receiver != null) {
System.out.println(sender.getName() + " sends a message to " + receiver.getName() + ": " + message);
// 这里可以添加额外的逻辑，比如记录消息、通知其他服务等
} else {
System.out.println("Receiver " + receiverName + " is not online.");
}
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
// 创建中介者和用户
ChatMediator chatMediator = new ChatMediator();
User alice = new User("Alice", chatMediator);
User bob = new User("Bob", chatMediator);
// 用户注册到中介者
chatMediator.registerUser(alice);
chatMediator.registerUser(bob);
// Alice通过中介者发送消息给Bob
alice.sendMessage("Bob", "Hi Bob, how are you?");
// Bob通过中介者回复消息给Alice
bob.sendMessage("Alice", "I'm good, thanks!");
// 尝试发送消息给一个未注册的用户
alice.sendMessage("Charlie", "Hey Charlie, are you there?");
}
}
输出结果：
Alice sends a message to Bob: Hi Bob, how are you?
Bob sends a message to Alice: I'm good, thanks!
Receiver Charlie is not online.
在这个正例中，User类不直接持有对其他User对象的引用，而是通过ChatMediator中介者来发送消息，ChatMediator维护了一个用户列表，并负责将消息从发送者传递给接收者，这样，User类之间的耦合度降低了，因为用户不需要知道如何与其他用户直接通信，他们只需要与中介者交互。此外，如果未来需要改变通信方式或添加额外的通信逻辑，只需要修改ChatMediator类即可，而不影响User类。
中介者模式总结
通过引入中介者，使得各个组件之间不再直接相互依赖，减少了系统的复杂性，他将原本分散的交互逻辑集中管理，使得这些逻辑更加清晰和易于维护，由于组件间的通信都通过中介者进行，因此添加新组件或修改现有组件的交互方式变得更加容易。但随着系统的扩展，它可能需要处理越来越多的交互逻辑，导致其代码变得庞大且难以维护，为了实现中介者模式，有时可能需要创建额外的抽象类和接口，这可能会增加系统的复杂性和理解难度。
在确实需要降低组件间耦合度的情况下使用中介者模式，避免过度设计，可以考虑与其他设计模式（如观察者模式）结合使用，以实现更灵活和强大的功能。
和其它模式对比
中介者模式和装饰者模式两者的区别：
中介者模式主要用于降低多个对象之间的耦合度，通过引入一个中介者对象，其它所有相关对象都通过该中介者对象进行通信，而不是直接相互引用，当中介者模式中的某一个对象发生改变时，只需要通知中介者对象，由中介者对象负责与其他对象的交互，这样可以简化对象之间的交互，降低系统的复杂性。
装饰者模式则侧重于在不改变对象自身的基础上，动态地给对象添加新的功能或方法，装饰者模式通过创建一个装饰类，将原始类作为成员变量进行包装，并在装饰类中提供与原始类相同的方法，这些方法可以在调用原始类方法之前或之后执行一些额外的操作，这样可以实现对原始类功能的动态扩展，而无需修改原始类的代码。
总结，中介者模式主要用于解决对象之间的紧耦合问题，通过引入中介者来协调对象之间的交互；而装饰者模式则主要用于在不改变原始类的基础上，动态地给对象添加新的功能或方法。
Recommend
About Joyk
Aggregate valuable and interesting links.
Joyk means Joy of geeK