当前位置： 首页 > backend >正文

零基础设计模式——行为型模式 - 中介者模式

backend 2025/6/21 13:06:16

第四部分：行为型模式 - 中介者模式 (Mediator Pattern)

接下来，我们学习中介者模式。这个模式用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

  • 核心思想：用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

中介者模式 (Mediator Pattern)

“用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。” (Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.)

想象一个机场的控制塔：

  • 飞机 (Colleague Objects)：多架飞机在机场附近飞行，准备降落或起飞。
  • 控制塔 (Mediator)：控制塔负责协调所有飞机的行动。飞机不直接相互通信来决定谁先降落、谁使用哪个跑道。它们都只与控制塔通信。
  • 通信 (Interaction)：飞机向控制塔报告自己的状态和意图（如请求降落），控制塔根据整体情况向飞机发出指令（如允许降落、指定跑道、等待）。

如果没有控制塔，飞机之间需要复杂的直接通信来避免碰撞和混乱，这将形成一个复杂的网状通信结构。控制塔将这种网状结构简化为星型结构，所有通信都通过中心节点（控制塔）进行。

1. 目的 (Intent)

中介者模式的主要目的：

  1. 减少对象间的直接依赖：将对象间复杂的网状依赖关系转变为星型依赖关系。各个同事对象不再直接相互引用，而是都只引用中介者。
  2. 集中控制交互逻辑：对象间的交互逻辑被封装在中介者对象中，使得交互逻辑更易于理解和维护。
  3. 促进松耦合：同事对象之间松散耦合，它们可以独立地变化和复用。
  4. 提高系统的可扩展性：当需要修改或增加交互行为时，通常只需要修改中介者类，或者增加新的中介者类，而不需要修改大量的同事类。

2. 生活中的例子 (Real-world Analogy)

  • 聊天室 (Chat Room)：

    • 用户 (Colleague Objects)：聊天室中的多个用户。
    • 聊天室服务器 (Mediator)：用户发送消息给服务器，服务器再将消息广播给聊天室中的其他用户（或特定用户）。用户之间不直接点对点发送消息。

  • 联合国安理会 (UN Security Council)：

    • 国家 (Colleague Objects)：各个成员国。
    • 安理会 (Mediator)：国家之间通过安理会这个平台进行沟通、协调和决策，而不是所有国家都两两直接谈判所有事务。

  • GUI应用程序中的对话框 (Dialog Box)：

    • 各种控件 (Colleague Objects)：如按钮、文本框、列表框、复选框等。
    • 对话框本身 (Mediator)：对话框负责协调其内部控件之间的交互。例如，当一个列表框的选择改变时，对话框可能会启用或禁用某个按钮，或者更新某个文本框的内容。控件之间不直接相互操作。

3. 结构 (Structure)

中介者模式通常包含以下角色：

  1. Mediator (中介者接口/抽象类)：定义一个接口用于与各个同事对象通信。它通常包含一个方法，供同事对象在自身状态改变时通知中介者。
  2. ConcreteMediator (具体中介者)：实现 Mediator 接口。它了解并维护所有的具体同事类，并负责协调它们之间的交互。它封装了同事之间的复杂交互逻辑。
  3. Colleague (同事接口/抽象类)：定义一个接口，包含一个指向中介者对象的引用。每个同事类都知道其中介者对象。
  4. ConcreteColleague (具体同事类)：实现 Colleague 接口。每个具体同事类只知道自己的行为，当需要与其他同事交互时，它会通知中介者，由中介者去协调。
    在这里插入图片描述
    工作流程：
  • 客户端创建具体中介者对象和所有具体同事对象。
  • 客户端将中介者对象设置给每个同事对象，并将每个同事对象注册到中介者中。
  • 当一个同事对象发生变化或需要与其他同事交互时（例如，用户在GUI中点击了一个按钮 ConcreteColleagueA）：
    • 该同事对象会调用其 changed() 方法，通知中介者 (ConcreteMediator)。
    • 中介者接收到通知后，根据预定义的交互逻辑，可能会调用其他同事对象的方法（例如，中介者调用 ConcreteColleagueB.someOperationB()）。
  • 同事对象之间不直接通信，所有交互都通过中介者进行。

4. 适用场景 (When to Use)

  • 当一组对象以定义良好但复杂的方式进行通信，导致了对象之间存在大量相互依赖和直接引用时（网状结构）。
  • 当一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象时。
  • 当你想自定义一个分布在多个类中的行为，而又不想生成太多子类时。可以将这些行为提取到中介者中。
  • 在GUI设计中，组件之间的复杂交互（例如，一个组件的状态变化影响其他多个组件）是中介者模式的经典应用场景。

5. 优缺点 (Pros and Cons)

优点：

  1. 减少了类间的依赖：将对象之间复杂的网状通信结构简化为星型结构，降低了同事类之间的耦合度。
  2. 集中控制交互：将对象间的交互行为封装在中介者对象中，使得交互逻辑更易于理解、维护和修改。
  3. 符合迪米特法则：同事类只需要与中介者通信，不需要了解其他同事类。
  4. 提高了同事类的可复用性：由于同事类之间的耦合降低，它们更容易被复用。
  5. 提高了系统的灵活性和可扩展性：修改交互行为通常只需要修改中介者，而不需要修改各个同事类。

缺点：

  1. 中介者可能变得庞大复杂：如果系统中同事对象过多，或者交互逻辑过于复杂，中介者类可能会变得非常庞大，承担过多的责任，难以维护（演变成上帝类 God Object）。
  2. 增加了中介者类：引入了额外的中介者类，增加了系统的类数量。

6. 实现方式 (Implementations)

让我们以一个简单的聊天室为例。用户 (User) 是同事，聊天室 (ChatRoom) 是中介者。

同事接口 (ChatUser - Colleague)
// chat_user.go (Colleague interface - can be an abstract struct or interface)
package colleague// Mediator 定义了中介者需要暴露给同事的方法
type Mediator interface {SendMessage(message string, sender User)
}// User 定义了同事需要暴露给中介者的方法，以及同事自身的方法
type User interface {GetName() stringReceiveMessage(message string, senderName string)Send(message string) // 同事通过此方法经由中介者发送消息SetMediator(mediator Mediator)
}

// User.java (Colleague abstract class or interface)
package com.example.colleague;import com.example.mediator.ChatMediator;public abstract class User {protected ChatMediator mediator;protected String name;public User(ChatMediator mediator, String name) {this.mediator = mediator;this.name = name;}public String getName() {return name;}// 同事发送消息，通过中介者public abstract void send(String message);// 同事接收消息public abstract void receive(String message, String senderName);
}
具体同事 (ConcreteUser - ConcreteColleague)
// concrete_user.go
package colleagueimport "fmt"// ConcreteUser 实现了 User 接口
type ConcreteUser struct {name     stringmediator Mediator
}func NewConcreteUser(name string) *ConcreteUser {return &ConcreteUser{name: name}
}func (u *ConcreteUser) SetMediator(mediator Mediator) {u.mediator = mediator
}func (u *ConcreteUser) GetName() string {return u.name
}func (u *ConcreteUser) Send(message string) {fmt.Printf("%s sends: %s\n", u.name, message)if u.mediator != nil {u.mediator.SendMessage(message, u) // 通过中介者发送}
}func (u *ConcreteUser) ReceiveMessage(message string, senderName string) {fmt.Printf("%s receives from %s: %s\n", u.name, senderName, message)
}

// ConcreteUser.java (ConcreteColleague)
package com.example.colleague;import com.example.mediator.ChatMediator;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;public class ConcreteUser extends User {public ConcreteUser(ChatMediator mediator, String name) {super(mediator, name);}@Overridepublic void send(String message) {String time = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"));System.out.println(time + " [" + this.name + "] sends: " + message);mediator.sendMessage(message, this);}@Overridepublic void receive(String message, String senderName) {String time = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"));System.out.println(time + " [" + this.name + "] received from [" + senderName + "]: " + message);}
}
中介者接口 (ChatMediator - Mediator)
// chat_mediator.go (Mediator interface - already defined in colleague/chat_user.go for Go)
// For clarity, we can define it in its own package if preferred.
// package mediator
// type ChatMediator interface {
//    SendMessage(message string, sender colleague.User)
//    AddUser(user colleague.User)
// }

// ChatMediator.java (Mediator interface)
package com.example.mediator;import com.example.colleague.User;public interface ChatMediator {void sendMessage(String message, User sender);void addUser(User user);
}
具体中介者 (ConcreteChatRoom - ConcreteMediator)
// concrete_chat_room.go
package mediator // Assuming this is in a 'mediator' packageimport ("../colleague" // Path to colleague package"fmt"
)// ConcreteChatRoom 实现了 colleague.Mediator 接口
type ConcreteChatRoom struct {users []colleague.User
}func NewConcreteChatRoom() *ConcreteChatRoom {return &ConcreteChatRoom{users: make([]colleague.User, 0),}
}func (cr *ConcreteChatRoom) AddUser(user colleague.User) {fmt.Printf("ChatRoom: %s joined.\n", user.GetName())cr.users = append(cr.users, user)user.SetMediator(cr) // 关键：将中介者设置给同事
}// SendMessage 是 colleague.Mediator 接口的实现
func (cr *ConcreteChatRoom) SendMessage(message string, sender colleague.User) {for _, u := range cr.users {// 不把消息发回给发送者自己if u.GetName() != sender.GetName() {u.ReceiveMessage(message, sender.GetName())}}
}

// ConcreteChatMediator.java (ConcreteMediator)
package com.example.mediator;import com.example.colleague.User;
import java.util.ArrayList;
import java.util.List;public class ConcreteChatMediator implements ChatMediator {private List<User> users;public ConcreteChatMediator() {this.users = new ArrayList<>();}@Overridepublic void addUser(User user) {System.out.println("ChatRoom: " + user.getName() + " joined the chat.");this.users.add(user);// In Java, the mediator is typically passed to User's constructor,// so no need for user.setMediator(this) here if done in constructor.}@Overridepublic void sendMessage(String message, User sender) {for (User user : users) {// Don't send the message back to the senderif (user != sender) {user.receive(message, sender.getName());}}}
}
客户端使用
// main.go (示例用法)
/*
package mainimport ("./colleague""./mediator"
)func main() {chatRoom := mediator.NewConcreteChatRoom()user1 := colleague.NewConcreteUser("Alice")user2 := colleague.NewConcreteUser("Bob")user3 := colleague.NewConcreteUser("Charlie")// 用户加入聊天室，聊天室会自动设置自己为用户的中介者chatRoom.AddUser(user1)chatRoom.AddUser(user2)chatRoom.AddUser(user3)fmt.Println("\n--- Chatting Starts ---")user1.Send("Hi everyone!")// Expected:// Alice sends: Hi everyone!// Bob receives from Alice: Hi everyone!// Charlie receives from Alice: Hi everyone!fmt.Println("\n")user2.Send("Hello Alice!")// Expected:// Bob sends: Hello Alice!// Alice receives from Bob: Hello Alice!// Charlie receives from Bob: Hello Alice!
}
*/

// Main.java (示例用法)
/*
package com.example;import com.example.colleague.ConcreteUser;
import com.example.colleague.User;
import com.example.mediator.ChatMediator;
import com.example.mediator.ConcreteChatMediator;public class Main {public static void main(String[] args) {ChatMediator chatRoom = new ConcreteChatMediator();User user1 = new ConcreteUser(chatRoom, "Alice");User user2 = new ConcreteUser(chatRoom, "Bob");User user3 = new ConcreteUser(chatRoom, "Charlie");chatRoom.addUser(user1);chatRoom.addUser(user2);chatRoom.addUser(user3);System.out.println("\n--- Chatting Starts ---");user1.send("Hi everyone!");// Expected output will show timestamps and formatted messagesSystem.out.println(""); // For spacinguser2.send("Hello Alice! How are you?");System.out.println("");user3.send("I'm good, thanks for asking!");}
}
*/

7. 总结

中介者模式通过引入一个中心协调对象（中介者），将系统中原本复杂的对象间网状交互结构转变为星型结构。这有效地降低了对象之间的耦合度，使得各个对象（同事）可以独立变化，同时也使得交互逻辑集中在中介者中，更易于管理和维护。虽然它可能导致中介者自身变得复杂，但在处理多对多对象交互的场景下，中介者模式提供了一种优雅且有效的解决方案，尤其在GUI开发和需要解耦多个协作组件的系统中非常有用。

http://www.xdnf.cn/news/13497.html

相关文章：

  • 使用Jmeter做功能测试有哪些优点？
  • C++ 中的 iostream 库：cin/cout 基本用法
  • Python训练第五十天
  • milvus 总结
  • Uniapp实现多选下拉框
  • 微信小程序Echarts开发问题
  • Vue 数据代理机制对属性名的要求
  • 如何正确的用Trae 打开 Unity 3D 项目
  • 计算机视觉与深度学习 ｜ 基于Matlab的低照度图像增强算法：全面总结与实现
  • 问题八、Articulation中的actuator（执行器）
  • PostgresSQL日常维护
  • Jenkins + Docker + Kubernetes（JKD）自动化部署全链路实践
  • Axure应用交互设计：文本输入计数、显示输入内容、AI对话
  • 适配器模式深度解析：Java设计模式实战指南与接口兼容性解决方案
  • SpringMVC（1）
  • 安全生产管理是什么？安全生产管理主要管什么？
  • Oracle查看锁表并终止会话
  • Hive面试题汇总
  • X86 OpenHarmony5.1.0系统移植与安装
  • IDE（集成开发环境），集成阿里云的通义大模型
  • 京东商品详情API接口返回的JSON结构中，price字段的数据类型是什么
  • 四大LLM 微调开源工具包深度解析
  • WPF案例展示
  • Spring @Scope, @Lazy, @DependsOn, @Required, @Lookup
  • 阿里云可观测 2025 年 5 月产品动态
  • 2506C++,C++时间库与C时间
  • java使用WebMagic架构写个分布式爬虫
  • React Vue 编译/运行流程
  • 入门Scikit-learn：让机器学习像呼吸一样自然！
  • thinkphp 一个系统在同一个域名下，一个文件夹下如何区分多站点——穷人的精致规划——仙盟创梦IDE