中介者模式¶
目录¶
1. 中介者模式简介¶
中介者模式（Mediator Pattern）是一种行为型设计模式，它通过一个中介对象来封装一系列对象的交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，并且可以独立地改变它们之间的交互。该模式的核心思想是引入一个中介者对象来管理对象之间的通信，避免对象之间的直接依赖。
关键点：
集中管理：所有对象的交互都通过中介者进行，集中管理对象之间的通信。
降低耦合度：对象无需直接引用其他对象，降低了系统的耦合度。
增强灵活性：通过修改中介者，可以轻松改变对象之间的交互方式，而无需修改各个对象。
2. 中介者模式的意图¶
中介者模式的主要目的是：
封装对象之间的交互：通过中介者对象集中管理和协调多个对象之间的交互。
降低对象之间的耦合度：对象不需要知道其他对象的具体信息，只需要与中介者通信。
简化对象间的依赖关系：避免对象之间形成复杂的网状结构，使系统更易于理解和维护。
提高系统的灵活性和可扩展性：通过更改中介者的实现，可以轻松调整对象之间的交互逻辑，而无需修改对象本身。
3. 中介者模式的结构¶
3.1. 结构组成¶
中介者模式主要由以下四个角色组成：
Mediator（中介者接口）：定义了一个接口，用于与各同事类通信。
ConcreteMediator（具体中介者）：实现了Mediator接口，协调各同事类之间的交互。
Colleague（同事类）：每个同事类都持有对中介者的引用，通过中介者与其他同事类通信。
Client（客户端）：创建具体中介者和同事类对象，并设置它们之间的关系。
角色关系：
Client 创建并初始化 ConcreteMediator 和 Colleague 对象，设置它们之间的关系。
ConcreteMediator 维护并协调 Colleague 之间的交互。
Colleague 通过中介者接口与其他同事类进行通信，而不直接引用它们。
3.2. UML类图¶
以下是中介者模式的简化UML类图：
+------------------------+
| Client |
+------------------------+
| - mediator: Mediator |
| - colleague1: Colleague|
| - colleague2: Colleague|
| + main() |
+------------------------+
| 创建
v
+-----------------------------------------------+
| Mediator |
+-----------------------------------------------+
| + notify(colleague: Colleague, event: String) |
+-----------------------------------------------+
^
|
+----------------------------+
| ConcreteMediator |
+----------------------------+
| - colleague1: Colleague |
| - colleague2: Colleague |
+----------------------------+
| + notify(colleague, event) |
+----------------------------+
/_\
|
+---------------------+ +---------------------+
| Colleague | | Colleague |
+---------------------+ +---------------------+
| - mediator: Mediator| | - mediator: Mediator|
+---------------------+ +---------------------+
| + send(message) | | + send(message) |
| + receive(message) | | + receive(message) |
+---------------------+ +---------------------+
说明：
Client 创建了具体的同事类和中介者，并将同事类注册到中介者中。
ConcreteMediator 持有对同事类的引用，并在接收到同事类的消息时，协调其他同事类的响应。
Colleague 通过中介者发送和接收消息，而不直接与其他同事类交互。
4. 中介者模式的实现¶
以下示例将展示如何在Java和Python中实现中介者模式。以一个简单的聊天室系统为例，实现用户之间的消息传递通过中介者来协调。
4.1. Java 实现示例¶
示例说明¶
我们将实现一个简单的聊天室系统，其中中介者负责协调用户之间的消息传递，用户无需直接与其他用户通信。
代码实现¶
// Mediator接口
public interface Mediator {
void sendMessage(String message, Colleague colleague);
void addColleague(Colleague colleague);
}
// ConcreteMediator类
import java.util.ArrayList;
import java.util.List;
public class ChatMediator implements Mediator {
private List<Colleague> colleagues;
public ChatMediator(){
colleagues = new ArrayList<>();
}
@Override
public void addColleague(Colleague colleague){
colleagues.add(colleague);
}
@Override
public void sendMessage(String message, Colleague sender){
for(Colleague colleague : colleagues){
// 不发送给自己
if(colleague != sender){
colleague.receive(message);
}
}
}
}
// Colleague抽象类
public abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator mediator){
this.mediator = mediator;
}
public abstract void send(String message);
public abstract void receive(String message);
}
// ConcreteColleague类
public class User extends Colleague {
private String name;
public User(Mediator mediator, String name){
super(mediator);
this.name = name;
mediator.addColleague(this);
}
@Override
public void send(String message){
System.out.println(this.name + " 发送消息: " + message);
mediator.sendMessage(message, this);
}
@Override
public void receive(String message){
System.out.println(this.name + " 接收到消息: " + message);
}
}
// 客户端代码
public class MediatorPatternDemo {
public static void main(String[] args) {
Mediator mediator = new ChatMediator();
Colleague user1 = new User(mediator, "Alice");
Colleague user2 = new User(mediator, "Bob");
Colleague user3 = new User(mediator, "Charlie");
user1.send("大家好！");
System.out.println();
user2.send("你好，Alice！");
System.out.println();
user3.send("大家晚上好！");
}
}
输出¶
Alice 发送消息: 大家好！
Bob 接收到消息: 大家好！
Charlie 接收到消息: 大家好！
Bob 发送消息: 你好，Alice！
Alice 接收到消息: 你好，Alice！
Charlie 接收到消息: 你好，Alice！
Charlie 发送消息: 大家晚上好！
Alice 接收到消息: 大家晚上好！
Bob 接收到消息: 大家晚上好！
代码说明¶
Mediator接口：定义了发送消息和添加同事的方法。
ChatMediator类：实现了Mediator接口，维护了一个同事列表，并负责协调消息的发送。
Colleague抽象类：定义了发送和接收消息的接口，并持有对Mediator的引用。
User类：具体的同事类，实现了发送和接收消息的逻辑。
MediatorPatternDemo类：客户端，创建了中介者和用户对象，并模拟了用户之间的消息传递。
4.2. Python 实现示例¶
示例说明¶
同样，实现一个简单的聊天室系统，用户通过中介者发送和接收消息。
代码实现¶
from abc import ABC, abstractmethod
# Mediator接口
class Mediator(ABC):
@abstractmethod
def send_message(self, message: str, colleague):
pass
@abstractmethod
def add_colleague(self, colleague):
pass
# ConcreteMediator类
class ChatMediator(Mediator):
def __init__(self):
self.colleagues = []
def add_colleague(self, colleague):
self.colleagues.append(colleague)
def send_message(self, message: str, sender):
for colleague in self.colleagues:
if colleague != sender:
colleague.receive(message)
# Colleague抽象类
class Colleague(ABC):
def __init__(self, mediator: Mediator):
self.mediator = mediator
self.mediator.add_colleague(self)
@abstractmethod
def send(self, message: str):
pass
@abstractmethod
def receive(self, message: str):
pass
# ConcreteColleague类
class User(Colleague):
def __init__(self, mediator: Mediator, name: str):
super().__init__(mediator)
self.name = name
def send(self, message: str):
print(f"{self.name} 发送消息: {message}")
self.mediator.send_message(message, self)
def receive(self, message: str):
print(f"{self.name} 接收到消息: {message}")
# 客户端代码
def mediator_pattern_demo():
mediator = ChatMediator()
user1 = User(mediator, "Alice")
user2 = User(mediator, "Bob")
user3 = User(mediator, "Charlie")
user1.send("大家好！")
print()
user2.send("你好，Alice！")
print()
user3.send("大家晚上好！")
if __name__ == "__main__":
mediator_pattern_demo()
输出¶
Alice 发送消息: 大家好！
Bob 接收到消息: 大家好！
Charlie 接收到消息: 大家好！
Bob 发送消息: 你好，Alice！
Alice 接收到消息: 你好，Alice！
Charlie 接收到消息: 你好，Alice！
Charlie 发送消息: 大家晚上好！
Alice 接收到消息: 大家晚上好！
Bob 接收到消息: 大家晚上好！
代码说明¶
Mediator抽象类：定义了发送消息和添加同事的方法。
ChatMediator类：实现了Mediator接口，维护了一个同事列表，并负责协调消息的发送。
Colleague抽象类：定义了发送和接收消息的接口，并持有对Mediator的引用。
User类：具体的同事类，实现了发送和接收消息的逻辑。
mediator_pattern_demo函数：客户端，创建了中介者和用户对象，并模拟了用户之间的消息传递。
5. 中介者模式的适用场景¶
中介者模式适用于以下场景：
对象之间存在复杂的交互关系：当多个对象之间存在复杂的交互和依赖关系时，中介者模式可以通过引入中介者来简化这些交互。
需要集中控制对象之间的通信：通过中介者对象集中管理和协调对象之间的通信，便于维护和管理。
希望降低系统的耦合度：对象通过中介者进行通信，避免了对象之间的直接引用，降低了系统的耦合度。
需要动态地改变对象之间的交互：通过修改中介者的实现，可以灵活地调整对象之间的交互方式，而无需修改各个对象。
系统中有大量的对象相互协作：中介者模式可以减少对象之间的直接依赖，避免系统中出现对象间的网状依赖结构。
示例应用场景：
图形用户界面（GUI）系统：窗口中的各个组件（按钮、文本框、标签等）通过中介者进行交互，避免组件之间的直接依赖。
多人聊天室系统：用户通过中介者（聊天室）发送和接收消息，避免用户之间的直接通信。
航空交通控制系统：各个飞行器通过中介者（控制塔）进行通信和协调，避免飞行器之间的直接通信。
电子商务系统中的订单处理：各个模块（库存、支付、物流等）通过中介者进行协调，避免模块之间的直接依赖。
智能家居系统：各种设备通过中介者（中央控制器）进行通信和控制，避免设备之间的直接通信。
6. 中介者模式的优缺点¶
6.1. 优点¶
降低系统的耦合度：通过引入中介者，系统中的各个对象不需要直接相互引用，减少了对象之间的依赖关系。
简化对象间的通信：所有对象的交互都通过中介者进行，避免了对象之间形成复杂的网状结构。
集中管理：中介者对象负责协调和管理对象之间的交互，便于维护和管理。
增强系统的灵活性和可扩展性：通过修改中介者的实现，可以轻松改变对象之间的交互方式，而无需修改各个对象。
提高复用性：通过中介者，可以复用已有的对象，而无需了解它们的内部实现。
6.2. 缺点¶
中介者可能过于复杂：随着系统规模的扩大，中介者可能会变得非常复杂，承担过多的职责，导致单一职责原则被破坏。
中介者成为系统的核心：系统的所有交互都依赖于中介者，如果中介者出现问题，可能会影响整个系统的运行。
增加系统的维护成本：中介者负责协调对象之间的交互，随着对象数量的增加，中介者的逻辑也会变得复杂，增加了维护成本。
可能违反开闭原则：中介者需要频繁修改以适应对象之间的新交互，可能导致违反开闭原则（对扩展开放，对修改封闭）。
7. 中介者模式的常见误区与解决方案¶
7.1. 误区1：将所有对象的交互都通过中介者处理¶
问题描述： 开发者可能倾向于将系统中所有对象的交互都通过中介者来处理，导致中介者承担过多的职责，变得过于复杂。
解决方案：
明确职责边界：仅将对象之间的关键交互通过中介者处理，对于简单的交互，允许对象之间直接通信。
分层中介者：如果系统中存在多个不同的交互场景，可以引入多个中介者，每个中介者负责特定的交互逻辑，避免单一中介者过于庞大。
遵循单一职责原则：确保中介者只负责协调对象之间的交互，而不承担其他业务逻辑。
7.2. 误区2：中介者直接处理业务逻辑¶
问题描述： 中介者不仅协调对象之间的通信，还直接处理业务逻辑，导致中介者与具体的业务耦合。
解决方案：
保持中介者的中立性：中介者只负责协调对象之间的交互，不直接处理业务逻辑。业务逻辑应由各个对象自身或其他专门的类来处理。
使用职责分离：将业务逻辑与通信协调分离，确保中介者仅承担通信协调的职责。
7.3. 误区3：忽视中介者的可扩展性¶
问题描述： 在设计中介者时未考虑到未来可能的扩展需求，导致中介者难以适应新的交互场景。
解决方案：
设计灵活的接口：确保中介者接口具有足够的灵活性，以支持不同类型的交互请求。
模块化设计：将中介者设计为模块化的组件，便于在需要时进行扩展和修改。
使用设计原则：遵循开闭原则，确保在不修改中介者核心代码的情况下，能够通过扩展类或接口来支持新的交互场景。
8. 中介者模式的实际应用实例¶
8.1. 聊天室系统¶
示例说明¶
实现一个简单的聊天室系统，用户通过中介者发送和接收消息，避免用户之间的直接通信。
Java实现¶
// Mediator接口
public interface Mediator {
void sendMessage(String message, User colleague);
void addUser(User user);
}
// ConcreteMediator类
import java.util.ArrayList;
import java.util.List;
public class ChatRoom implements Mediator {
private List<User> users;
public ChatRoom(){
users = new ArrayList<>();
}
@Override
public void addUser(User user){
users.add(user);
}
@Override
public void sendMessage(String message, User sender){
for(User user : users){
if(user != sender){
user.receive(message);
}
}
}
}
// Colleague类
public abstract class User {
protected Mediator mediator;
protected String name;
public User(Mediator mediator, String name){
this.mediator = mediator;
this.name = name;
mediator.addUser(this);
}
public abstract void send(String message);
public abstract void receive(String message);
}
// ConcreteColleague类
public class ChatUser extends User {
public ChatUser(Mediator mediator, String name){
super(mediator, name);
}
@Override
public void send(String message){
System.out.println(this.name + " 发送消息: " + message);
mediator.sendMessage(message, this);
}
@Override
public void receive(String message){
System.out.println(this.name + " 接收到消息: " + message);
}
}
// 客户端代码
public class MediatorPatternDemo {
public static void main(String[] args) {
Mediator chatRoom = new ChatRoom();
User user1 = new ChatUser(chatRoom, "Alice");
User user2 = new ChatUser(chatRoom, "Bob");
User user3 = new ChatUser(chatRoom, "Charlie");
user1.send("大家好！");
System.out.println();
user2.send("你好，Alice！");
System.out.println();
user3.send("大家晚上好！");
}
}
输出¶
Alice 发送消息: 大家好！
Bob 接收到消息: 大家好！
Charlie 接收到消息: 大家好！
Bob 发送消息: 你好，Alice！
Alice 接收到消息: 你好，Alice！
Charlie 接收到消息: 你好，Alice！
Charlie 发送消息: 大家晚上好！
Alice 接收到消息: 大家晚上好！
Bob 接收到消息: 大家晚上好！
代码说明¶
Mediator接口：定义了发送消息和添加用户的方法。
ChatRoom类：实现了Mediator接口，维护了一个用户列表，并负责协调消息的发送。
User抽象类：定义了发送和接收消息的接口，并持有对Mediator的引用。
ChatUser类：具体的用户类，实现了发送和接收消息的逻辑。
MediatorPatternDemo类：客户端，创建了中介者和用户对象，并模拟了用户之间的消息传递。
8.2. GUI组件管理¶
示例说明¶
在图形用户界面（GUI）系统中，窗口中的各个组件（如按钮、文本框、标签等）通过中介者进行交互。例如，当一个按钮被点击时，中介者可以协调其他组件的响应，如更新文本框的内容或改变标签的显示。
Python实现¶
from abc import ABC, abstractmethod
# Mediator接口
class Mediator(ABC):
@abstractmethod
def notify(self, sender, event):
pass
# ConcreteMediator类
class GUIChatMediator(Mediator):
def __init__(self):
self.button = None
self.textbox = None
self.label = None
def set_button(self, button):
self.button = button
def set_textbox(self, textbox):
self.textbox = textbox
def set_label(self, label):
self.label = label
def notify(self, sender, event):
if sender == self.button and event == "click":
message = self.textbox.get_text()
self.label.set_text(f"按钮点击，文本框内容: {message}")
# Colleague类
class GUIComponent(ABC):
def __init__(self, mediator: Mediator):
self.mediator = mediator
class Button(GUIComponent):
def click(self):
print("按钮被点击")
self.mediator.notify(self, "click")
class TextBox(GUIComponent):
def __init__(self, mediator: Mediator, text: str = ""):
super().__init__(mediator)
self.text = text
def set_text(self, text: str):
self.text = text
def get_text(self) -> str:
return self.text
class Label(GUIComponent):
def __init__(self, mediator: Mediator):
super().__init__(mediator)
self.text = ""
def set_text(self, text: str):
self.text = text
print(f"标签显示: {self.text}")
# 客户端代码
def mediator_pattern_demo():
mediator = GUIChatMediator()
button = Button(mediator)
textbox = TextBox(mediator, "Hello, Mediator!")
label = Label(mediator)
mediator.set_button(button)
mediator.set_textbox(textbox)
mediator.set_label(label)
# 模拟用户输入
textbox.set_text("Mediator模式示例")
# 用户点击按钮
button.click()
if __name__ == "__main__":
mediator_pattern_demo()
输出¶
标签显示: 按钮点击，文本框内容: Mediator模式示例
按钮被点击
代码说明¶
Mediator抽象类：定义了通知方法
notify()，用于接收同事类的事件通知。GUIChatMediator类：实现了Mediator接口，持有各个组件的引用，并在收到事件通知时协调组件的响应。
GUIComponent抽象类：定义了组件基类，持有对Mediator的引用。
Button类：具体的按钮组件，模拟点击事件，并通知中介者。
TextBox类：具体的文本框组件，提供设置和获取文本的方法。
Label类：具体的标签组件，提供设置文本的方法，并在设置文本时输出显示内容。
mediator_pattern_demo函数：客户端，创建了中介者和各个组件对象，设置它们之间的关系，并模拟用户输入和按钮点击事件。
8.3. 航空交通控制系统¶
示例说明¶
在航空交通控制系统中，飞行器需要与控制塔进行通信，以获取起降许可和航线指令。通过中介者模式，可以实现飞行器与控制塔之间的解耦，所有通信通过中介者（控制塔）进行协调。
Java实现¶
// Mediator接口
public interface Mediator {
void registerAirplane(Airplane airplane);
void sendMessage(String message, Airplane airplane);
}
// ConcreteMediator类
import java.util.ArrayList;
import java.util.List;
public class AirTrafficControl implements Mediator {
private List<Airplane> airplanes;
public AirTrafficControl(){
airplanes = new ArrayList<>();
}
@Override
public void registerAirplane(Airplane airplane){
airplanes.add(airplane);
}
@Override
public void sendMessage(String message, Airplane sender){
System.out.println("控制塔接收到来自 " + sender.getName() + " 的消息: " + message);
for(Airplane airplane : airplanes){
if(airplane != sender){
airplane.receive(message);
}
}
}
}
// Colleague类
public abstract class Airplane {
protected Mediator mediator;
protected String name;
public Airplane(Mediator mediator, String name){
this.mediator = mediator;
this.name = name;
mediator.registerAirplane(this);
}
public abstract void send(String message);
public abstract void receive(String message);
public String getName(){
return this.name;
}
}
// ConcreteColleague类
public class CommercialAirplane extends Airplane {
public CommercialAirplane(Mediator mediator, String name){
super(mediator, name);
}
@Override
public void send(String message){
System.out.println(this.name + " 发送消息: " + message);
mediator.sendMessage(message, this);
}
@Override
public void receive(String message){
System.out.println(this.name + " 接收到消息: " + message);
}
}
// 客户端代码
public class MediatorPatternDemo {
public static void main(String[] args) {
Mediator mediator = new AirTrafficControl();
Airplane plane1 = new CommercialAirplane(mediator, "航班A");
Airplane plane2 = new CommercialAirplane(mediator, "航班B");
Airplane plane3 = new CommercialAirplane(mediator, "航班C");
plane1.send("请求起飞许可");
System.out.println();
plane2.send("请求降落许可");
System.out.println();
plane3.send("报告当前位置");
}
}
输出¶
航班A 发送消息: 请求起飞许可
控制塔接收到来自 航班A 的消息: 请求起飞许可
航班B 接收到消息: 请求起飞许可
航班C 接收到消息: 请求起飞许可
航班B 发送消息: 请求降落许可
控制塔接收到来自 航班B 的消息: 请求降落许可
航班A 接收到消息: 请求降落许可
航班C 接收到消息: 请求降落许可
航班C 发送消息: 报告当前位置
控制塔接收到来自 航班C 的消息: 报告当前位置
航班A 接收到消息: 报告当前位置
航班B 接收到消息: 报告当前位置
代码说明¶
Mediator接口：定义了注册飞行器和发送消息的方法。
AirTrafficControl类：实现了Mediator接口，维护了一个飞行器列表，并负责协调消息的发送。
Airplane抽象类：定义了发送和接收消息的接口，并持有对Mediator的引用和名称。
CommercialAirplane类：具体的飞行器类，实现了发送和接收消息的逻辑。
MediatorPatternDemo类：客户端，创建了中介者和飞行器对象，并模拟了飞行器之间的消息传递。
8.4. 电子商务系统中的订单处理¶
示例说明¶
在电子商务系统中，订单处理涉及多个模块，如库存管理、支付处理、物流配送等。通过中介者模式，可以实现这些模块之间的解耦，所有订单相关的操作通过中介者进行协调。
Python实现¶
from abc import ABC, abstractmethod
# Mediator接口
class Mediator(ABC):
@abstractmethod
def notify(self, sender, event):
pass
# ConcreteMediator类
class OrderMediator(Mediator):
def __init__(self):
self.inventory = None
self.payment = None
self.shipping = None
def set_inventory(self, inventory):
self.inventory = inventory
def set_payment(self, payment):
self.payment = payment
def set_shipping(self, shipping):
self.shipping = shipping
def notify(self, sender, event):
if sender == self.inventory and event == "in_stock":
self.payment.process_payment()
elif sender == self.payment and event == "payment_done":
self.shipping.ship_order()
elif sender == self.inventory and event == "out_of_stock":
print("商品缺货，无法完成订单。")
# Colleague类
class Inventory:
def __init__(self, mediator: Mediator):
self.mediator = mediator
self.mediator.set_inventory(self)
def check_stock(self, product: str):
# 简单模拟库存检查
if product == "Laptop":
print(f"{product} 有库存。")
self.mediator.notify(self, "in_stock")
else:
print(f"{product} 缺货。")
self.mediator.notify(self, "out_of_stock")
class Payment:
def __init__(self, mediator: Mediator):
self.mediator = mediator
self.mediator.set_payment(self)
def process_payment(self):
print("支付已完成。")
self.mediator.notify(self, "payment_done")
class Shipping:
def __init__(self, mediator: Mediator):
self.mediator = mediator
self.mediator.set_shipping(self)
def ship_order(self):
print("订单已发货。")
# 客户端代码
def mediator_pattern_demo():
mediator = OrderMediator()
inventory = Inventory(mediator)
payment = Payment(mediator)
shipping = Shipping(mediator)
# 客户端发起订单处理
print("客户下单购买 Laptop：")
inventory.check_stock("Laptop")
print("\n客户下单购买 Phone：")
inventory.check_stock("Phone")
if __name__ == "__main__":
mediator_pattern_demo()
输出¶
客户下单购买 Laptop：
Laptop 有库存。
支付已完成。
订单已发货。
客户下单购买 Phone：
Phone 缺货。
商品缺货，无法完成订单。
代码说明¶
Mediator抽象类：定义了通知方法
notify()，用于接收同事类的事件通知。OrderMediator类：实现了Mediator接口，持有库存、支付和物流模块的引用，并协调它们之间的交互。
Inventory类：库存管理模块，检查商品库存并通知中介者。
Payment类：支付处理模块，处理支付并通知中介者。
Shipping类：物流配送模块，处理订单发货。
mediator_pattern_demo函数：客户端，创建了中介者和各个模块对象，并模拟了客户下单的过程。
9. 中介者模式与其他模式的比较¶
9.1. 中介者模式 vs. 观察者模式¶
中介者模式用于集中管理对象之间的交互，通过中介者对象协调多个对象的通信。
观察者模式用于建立一对多的依赖关系，当一个对象状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。
关键区别：
目的不同：中介者模式关注对象之间的协调和交互，观察者模式关注对象状态的同步和通知。
结构不同：中介者模式引入中介者对象作为通信中心，观察者模式建立观察者和被观察者之间的直接关系。
耦合度：中介者模式通过中介者降低了对象之间的直接耦合，观察者模式对象之间仍然存在一定的耦合。
9.2. 中介者模式 vs. 责任链模式¶
中介者模式用于集中管理对象之间的交互，通过中介者对象协调多个对象的通信。
责任链模式用于将请求沿着一条链传递，直到有一个对象处理请求。
关键区别：
目的不同：中介者模式关注对象之间的协调与通信，责任链模式关注请求的处理流程。
结构不同：中介者模式引入一个中介者对象作为通信中心，责任链模式建立处理者链条，依次处理请求。
使用场景：中介者模式适用于复杂的对象交互场景，责任链模式适用于需要动态决定请求处理者的场景。
9.3. 中介者模式 vs. 装饰者模式¶
中介者模式用于集中管理对象之间的交互，通过中介者对象协调多个对象的通信。
装饰者模式用于动态地为对象添加新功能，通过装饰者对象包装原有对象，增强其功能。
关键区别：
目的不同：中介者模式关注对象之间的交互与协调，装饰者模式关注对象功能的扩展与增强。
结构不同：中介者模式引入中介者对象作为通信中心，装饰者模式通过继承或组合实现功能增强。
使用场景：中介者模式适用于复杂对象交互场景，装饰者模式适用于需要动态添加对象功能的场景。
9.4. 中介者模式 vs. 访问者模式¶
中介者模式用于集中管理对象之间的交互，通过中介者对象协调多个对象的通信。
访问者模式用于分离数据结构与数据操作，通过访问者对象遍历数据结构并执行操作。
关键区别：
目的不同：中介者模式关注对象之间的通信与协调，访问者模式关注对对象结构的遍历和操作。
结构不同：中介者模式引入中介者对象作为通信中心，访问者模式引入访问者接口和具体访问者类，通过双向调用实现操作。
使用场景：中介者模式适用于复杂对象交互场景，访问者模式适用于需要对对象结构执行多种操作的场景。
10. 总结¶
**中介者模式（Mediator Pattern）**通过引入一个中介者对象来集中管理和协调多个对象之间的交互，降低了对象之间的直接耦合，增强了系统的灵活性和可扩展性。该模式适用于对象之间存在复杂交互关系、需要集中管理通信流程的场景，尤其在需要动态调整对象间交互逻辑时，中介者模式提供了有效的解决方案。
关键学习点回顾：
理解中介者模式的核心概念：通过中介者对象集中管理和协调多个对象之间的交互，降低了对象之间的直接耦合。
掌握中介者模式的结构：包括Mediator接口、ConcreteMediator、Colleague抽象类、ConcreteColleague和Client之间的关系。
识别适用的应用场景：对象之间存在复杂交互关系、需要集中管理通信流程、希望降低系统耦合度等。
认识中介者模式的优缺点：降低耦合度、简化通信、增强灵活性和可扩展性；但可能导致中介者过于复杂、成为系统的核心、增加维护成本等。
理解常见误区及解决方案：避免中介者承担过多职责、保持中介者的中立性、确保中介者的可扩展性等。
实际应用中的中介者模式实例：聊天室系统、GUI组件管理、航空交通控制系统、电子商务系统中的订单处理等。
11. 参考资料¶
书籍：
《设计模式：可复用面向对象软件的基础》 by Erich Gamma 等（Gang of Four）
《Head First 设计模式》 by Eric Freeman 等
《Refactoring: Improving the Design of Existing Code》 by Martin Fowler
《Design Patterns: Elements of Reusable Object-Oriented Software》 by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
在线资源：
视频教程：
工具与实践：