中介者模式（Mediator Pattern）是一种行为型设计模式，用于减少多个对象或类之间的通信复杂性。这种模式通过引入一个中介对象来封装一系列对象间的交互方式，使得对象之间不需要显式地相互引用，从而使其耦合松散，可以独立地改变它们之间的交互。
1. 中介者模式的主要角色
- 中介者接口（Mediator）：定义了与同事类通信的接口，通常是一个抽象类或接口。
- 具体中介者（ConcreteMediator）：实现中介者接口，协调各个同事类对象之间的交互。具体中介者知道所有的同事类，并从同事类接收消息，根据这些消息协调各个同事类的行为。
- 同事类接口（Colleague）：定义了同事类的通用接口，通常是一个抽象类或接口。同事类需要与中介者通信，以实现与其他同事类的交互。
- 具体同事类（ConcreteColleague）：实现了同事类接口，定义了具体的行为。具体同事类知道自己的行为和状态，但不知道其他同事类的情况。它们通过中介者来与其他同事类通信。
2. 中介者模式的实现步骤
- 定义中介者接口：声明与同事类通信的方法。
- 实现具体中介者类：实现中介者接口，协调各个同事类对象之间的交互。
- 定义同事类接口：声明同事类的通用接口，通常包含一个方法用于与中介者通信。
- 实现具体同事类：实现同事类接口，定义具体的行为，并通过中介者与其他同事类通信。
- 客户端代码：创建具体中介者和具体同事类对象，并将同事类对象注册到中介者中。
3. 示例代码
假设我们有一个聊天室应用，用户可以发送消息给其他用户。我们可以使用中介者模式来实现这个需求。
3.1 定义中介者接口
public interface Mediator {
void sendMessage(String message, User user);
}
3.2 定义同事类接口
public interface User {
void sendMessage(String message);
void receiveMessage(String message);
}
3.3 实现具体中介者类
import java.util.ArrayList;
import java.util.List;
public class ChatRoomMediator implements Mediator {
private List<User> users = new ArrayList<>();
@Override
public void sendMessage(String message, User user) {
for (User u : users) {
if (u != user) {
u.receiveMessage(message);
}
}
}
public void addUser(User user) {
users.add(user);
}
}
3.4 实现具体同事类
public class UserImpl implements User {
private String name;
private Mediator mediator;
public UserImpl(String name, Mediator mediator) {
this.name = name;
this.mediator = mediator;
}
@Override
public void sendMessage(String message) {
System.out.println(name + " 发送消息: " + message);
mediator.sendMessage(message, this);
}
@Override
public void receiveMessage(String message) {
System.out.println(name + " 收到消息: " + message);
}
}
3.5 客户端代码
public class Main {
public static void main(String[] args) {
// 创建中介者
Mediator mediator = new ChatRoomMediator();
// 创建用户
User user1 = new UserImpl("Alice", mediator);
User user2 = new UserImpl("Bob", mediator);
User user3 = new UserImpl("Charlie", mediator);
// 将用户添加到中介者
mediator.addUser(user1);
mediator.addUser(user2);
mediator.addUser(user3);
// 发送消息
user1.sendMessage("Hello, everyone!");
user2.sendMessage("Hi Alice!");
}
}
4. 输出结果
运行客户端代码，输出结果如下：
Alice 发送消息: Hello, everyone!
Bob 收到消息: Hello, everyone!
Charlie 收到消息: Hello, everyone!
Bob 发送消息: Hi Alice!
Alice 收到消息: Hi Alice!
Charlie 收到消息: Hi Alice!
5. 中介者模式的优点
- 降低类之间的依赖：将一对多的依赖变成了一对一的依赖，同事类之间不再直接通信，而是通过中介者对象进行交互。
- 集中管理交互逻辑：将交互逻辑集中到中介者类中，便于理解和维护。
- 符合开闭原则：对扩展开放，对修改封闭，新增同事类或中介者类时，无需修改现有代码。
6. 适用场景
中介者模式适用于以下场景：
- 当对象之间存在复杂的引用关系，形成了网状结构时。
- 当需要集中管理多个对象之间的交互逻辑时。
- 当需要减少对象之间的直接通信，降低耦合度时。
通过中介者模式，可以有效地减少对象之间的直接通信，降低系统的耦合度，提高代码的可维护性和可扩展性。
中介者模式（Mediator Pattern）是一种行为设计模式，它通过一个中介对象来封装一系列对象之间的交互，使对象之间不再直接相互引用，从而降低了它们之间的耦合度，并且可以独立地改变它们之间的交互。
核心概念
- 中介者（Mediator）：定义了与各同事对象通信的接口，协调多个同事对象之间的交互。
- 具体中介者（Concrete Mediator）：实现中介者接口，具体协调各同事对象之间的交互，了解并维护各个同事对象。
- 同事类（Colleague）：定义了与中介者通信的接口，每个同事对象都知道它的中介者对象，通过中介者来与其他同事对象通信。
- 具体同事类（Concrete Colleague）：实现同事类接口，每个具体同事类只知道自己的行为，而不了解其他同事类的行为，它们之间的交互通过中介者来完成。
主要作用
- 降低耦合度：将对象之间的多对多关系转化为一对多关系，减少对象之间的直接依赖。
- 集中控制交互：将对象之间的交互逻辑集中在中介者中，便于维护和管理。
- 简化对象协议：对象之间的通信被简化为与中介者的通信，使协议更加清晰。
典型场景
- 对象之间存在复杂的网状交互：如GUI中的组件交互、多人游戏中的玩家交互等。
- 系统中对象之间的依赖关系结构混乱且难以理解：通过中介者模式可以使依赖关系更加清晰。
- 一个对象需要通知其他多个对象，但又不想显式地引用这些对象：如事件处理系统。
示例结构
下面是中介者模式的一个简单示例结构（Python 伪代码）：
from abc import ABC, abstractmethod
# 中介者接口
class Mediator(ABC):
@abstractmethod
def send(self, message, colleague):
pass
# 具体中介者
class ConcreteMediator(Mediator):
def __init__(self):
self.colleague1 = None
self.colleague2 = None
def set_colleague1(self, colleague):
self.colleague1 = colleague
def set_colleague2(self, colleague):
self.colleague2 = colleague
def send(self, message, colleague):
if colleague == self.colleague1:
self.colleague2.receive(message)
else:
self.colleague1.receive(message)
# 同事类接口
class Colleague(ABC):
def __init__(self, mediator):
self.mediator = mediator
@abstractmethod
def send(self, message):
pass
@abstractmethod
def receive(self, message):
pass
# 具体同事类
class ConcreteColleague1(Colleague):
def send(self, message):
print(f"同事1发送消息: {message}")
self.mediator.send(message, self)
def receive(self, message):
print(f"同事1收到消息: {message}")
class ConcreteColleague2(Colleague):
def send(self, message):
print(f"同事2发送消息: {message}")
self.mediator.send(message, self)
def receive(self, message):
print(f"同事2收到消息: {message}")
# 客户端代码
if __name__ == "__main__":
# 创建中介者
mediator = ConcreteMediator()
# 创建同事对象并关联中介者
colleague1 = ConcreteColleague1(mediator)
colleague2 = ConcreteColleague2(mediator)
# 中介者关联同事对象
mediator.set_colleague1(colleague1)
mediator.set_colleague2(colleague2)
# 同事1发送消息给同事2
colleague1.send("你好，同事2！")
# 同事2发送消息给同事1
colleague2.send("你好，同事1！")
优点
- 降低耦合度：对象之间的依赖关系被集中到中介者中，使得对象之间的耦合度大大降低。
- 便于复用：由于对象之间的交互被封装在中介者中，各个同事对象可以更容易地被复用。
- 简化系统结构：中介者模式将原本复杂的网状结构转化为简单的星型结构，使系统更加易于理解和维护。
缺点
- 中介者类可能过于复杂：如果同事对象之间的交互非常复杂，中介者类可能会变得庞大而难以维护。
- 可能导致单点故障：中介者类集中了所有的交互逻辑，如果中介者类出现问题，可能会导致整个系统无法正常工作。
- 违反开闭原则：如果需要添加新的同事对象，可能需要修改中介者类的代码。
与其他模式的区别
- 中介者模式 vs 观察者模式：
- 中介者模式：通过中介者对象来封装对象之间的交互，所有对象之间的通信都通过中介者进行。
- 观察者模式：通过发布-订阅机制实现对象之间的一对多依赖关系，当一个对象状态发生变化时，所有依赖它的对象都会得到通知。
- 中介者模式 vs 代理模式：
- 中介者模式：主要用于协调多个对象之间的交互，降低对象之间的耦合度。
- 代理模式：主要用于控制对另一个对象的访问，在访问对象时引入一定程度的间接性。
中介者模式在实际开发中常用于实现GUI组件交互、消息队列系统、多人游戏等场景，特别是当对象之间的交互关系复杂且难以维护时。通过中介者模式，可以将这些交互逻辑集中管理，使系统更加清晰和易于维护。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
