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

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

news 来源：原创 2025/6/14 1:06:10

第四部分：行为型模式 - 中介者模式 (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开发和需要解耦多个协作组件的系统中非常有用。

相关文章：

  • IDEA 连接 Docker 一键打镜像
  • k8s 部署服务常见错误原因
  • 【基于阿里云上Ubantu(x86-64)系统部署配置K8s】
  • Springboot+idea热更新
  • 句法分析 自然语言处理
  • springboot + nacos + k8s 优雅停机
  • redisson锁的可重入、可重试、超时续约原理详解
  • 第七章——8天Python从入门到精通【itheima】-81~82（函数的多返回值+函数多种传参方式）
  • 深入解析MySQL Join算法原理与性能优化实战指南
  • 附加模块--Qt SQL模块功能及架构解析
  • 在GIS 工作流中实现数据处理(2)
  • 小米15系列摄影进阶：100+专业级相机预设包实测与调参指南
  • Cockpit：一个开源的 Linux 系统管理工具
  • Postman核心功能解析
  • 【时时三省】(C语言基础)寄存器变量( register变量)和全局变量的存储类别
  • 顶级视频生成大模型分析：Seedance 1.0 Pro (字节跳动) - 新晋榜首
  • S2B2B农产品供应链交易多平台开发有哪些发展前景?如何维护?
  • 无线通信网络拓扑推理采样率实验（数据生成）
  • 数组——数组的遍历
  • Hive的索引使用如何优化？
  • 邢台规划局网站建设/电脑培训机构哪个好
  • 北京专业网站改版公司/网络广告营销成功案例
  • 明薇通网站建设首选/外贸推广平台哪个好
  • 上海人才网最新招聘信息2022年/seo外链自动群发工具
  • 手机网站怎么在电脑上打开/优化关键词排名提升
  • 全国今日生猪价格表/seo文章关键词怎么优化