中介者模式通过引入中介类降低对象间耦合度，在电商平台中，卖家、买家、物流公司和支付平台原本需复杂交互，在引入“交易中介”类后，各角色只需与中介交互，由中介协调各方操作，从而简化了交互流程，降低了类间依赖，使系统更灵活可维护。

定义

中介者模式主要用于减少类之间的耦合，它用一个中介类来封装一系列对象间的交互，使这些对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

举一个业务中的例子来说明，假设有一个电商平台，其中有卖家、买家、物流公司和支付平台四个角色，在没有中介者的情况下，这四个角色之间可能需要进行复杂的交互，比如卖家要直接联系物流公司发货，买家要直接联系支付平台进行支付等，这样的设计会导致类之间的耦合度很高，一旦某个角色发生变化，可能会影响到其他角色。

而引入中介者模式后，可以设计一个电商平台的“交易中介”类，这个类中介了卖家、买家、物流公司和支付平台之间的所有交互，卖家只需要将商品信息和买家信息提交给交易中介，交易中介会负责联系物流公司进行发货，并通知买家进行支付，买家支付完成后，交易中介会通知卖家和物流公司更新订单状态，这样，卖家、买家、物流公司和支付平台之间的耦合度就大大降低了，每个角色只需要和交易中介进行交互，而不需要直接和其他角色进行交互。

在这个场景中中，交易中介类就起到了中介者的作用，它将一系列对象间的交互封装起来，使这些对象之间的耦合度降低，提高了系统的灵活性和可维护性。

代码案例

反例

下面是一个未使用中介者模式的反例代码，假如，有一个聊天应用的简单模型，其中包括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类。

核心总结

中介者模式总结

通过引入中介者，使得各个组件之间不再直接相互依赖，减少了系统的复杂性，他将原本分散的交互逻辑集中管理，使得这些逻辑更加清晰和易于维护，由于组件间的通信都通过中介者进行，因此添加新组件或修改现有组件的交互方式变得更加容易。但随着系统的扩展，它可能需要处理越来越多的交互逻辑，导致其代码变得庞大且难以维护，为了实现中介者模式，有时可能需要创建额外的抽象类和接口，这可能会增加系统的复杂性和理解难度。

在确实需要降低组件间耦合度的情况下使用中介者模式，避免过度设计，可以考虑与其他设计模式（如观察者模式）结合使用，以实现更灵活和强大的功能。

和其它模式对比

中介者模式和装饰者模式两者的区别：

中介者模式主要用于降低多个对象之间的耦合度，通过引入一个中介者对象，其它所有相关对象都通过该中介者对象进行通信，而不是直接相互引用，当中介者模式中的某一个对象发生改变时，只需要通知中介者对象，由中介者对象负责与其他对象的交互，这样可以简化对象之间的交互，降低系统的复杂性。

装饰者模式则侧重于在不改变对象自身的基础上，动态地给对象添加新的功能或方法，装饰者模式通过创建一个装饰类，将原始类作为成员变量进行包装，并在装饰类中提供与原始类相同的方法，这些方法可以在调用原始类方法之前或之后执行一些额外的操作，这样可以实现对原始类功能的动态扩展，而无需修改原始类的代码。

总结，中介者模式主要用于解决对象之间的紧耦合问题，通过引入中介者来协调对象之间的交互；而装饰者模式则主要用于在不改变原始类的基础上，动态地给对象添加新的功能或方法。