第四部分：行为型模式 - 中介者模式 (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)
中介者模式的主要目的：
- 减少对象间的直接依赖：将对象间复杂的网状依赖关系转变为星型依赖关系。各个同事对象不再直接相互引用，而是都只引用中介者。
- 集中控制交互逻辑：对象间的交互逻辑被封装在中介者对象中，使得交互逻辑更易于理解和维护。
- 促进松耦合：同事对象之间松散耦合，它们可以独立地变化和复用。
- 提高系统的可扩展性：当需要修改或增加交互行为时，通常只需要修改中介者类，或者增加新的中介者类，而不需要修改大量的同事类。
2. 生活中的例子 (Real-world Analogy)
-
聊天室 (Chat Room)：
- 用户 (Colleague Objects)：聊天室中的多个用户。
- 聊天室服务器 (Mediator)：用户发送消息给服务器，服务器再将消息广播给聊天室中的其他用户（或特定用户）。用户之间不直接点对点发送消息。
-
联合国安理会 (UN Security Council)：
- 国家 (Colleague Objects)：各个成员国。
- 安理会 (Mediator)：国家之间通过安理会这个平台进行沟通、协调和决策，而不是所有国家都两两直接谈判所有事务。
-
GUI应用程序中的对话框 (Dialog Box)：
- 各种控件 (Colleague Objects)：如按钮、文本框、列表框、复选框等。
- 对话框本身 (Mediator)：对话框负责协调其内部控件之间的交互。例如，当一个列表框的选择改变时，对话框可能会启用或禁用某个按钮，或者更新某个文本框的内容。控件之间不直接相互操作。
3. 结构 (Structure)
中介者模式通常包含以下角色：
- Mediator (中介者接口/抽象类)：定义一个接口用于与各个同事对象通信。它通常包含一个方法，供同事对象在自身状态改变时通知中介者。
- ConcreteMediator (具体中介者)：实现 Mediator 接口。它了解并维护所有的具体同事类，并负责协调它们之间的交互。它封装了同事之间的复杂交互逻辑。
- Colleague (同事接口/抽象类)：定义一个接口，包含一个指向中介者对象的引用。每个同事类都知道其中介者对象。
- ConcreteColleague (具体同事类)：实现 Colleague 接口。每个具体同事类只知道自己的行为，当需要与其他同事交互时，它会通知中介者，由中介者去协调。
工作流程：
- 客户端创建具体中介者对象和所有具体同事对象。
- 客户端将中介者对象设置给每个同事对象，并将每个同事对象注册到中介者中。
- 当一个同事对象发生变化或需要与其他同事交互时（例如，用户在GUI中点击了一个按钮
ConcreteColleagueA）：- 该同事对象会调用其
changed()方法，通知中介者 (ConcreteMediator)。 - 中介者接收到通知后，根据预定义的交互逻辑，可能会调用其他同事对象的方法（例如，中介者调用
ConcreteColleagueB.someOperationB()）。
- 该同事对象会调用其
- 同事对象之间不直接通信，所有交互都通过中介者进行。
4. 适用场景 (When to Use)
- 当一组对象以定义良好但复杂的方式进行通信，导致了对象之间存在大量相互依赖和直接引用时（网状结构）。
- 当一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象时。
- 当你想自定义一个分布在多个类中的行为，而又不想生成太多子类时。可以将这些行为提取到中介者中。
- 在GUI设计中，组件之间的复杂交互（例如，一个组件的状态变化影响其他多个组件）是中介者模式的经典应用场景。
5. 优缺点 (Pros and Cons)
优点：
- 减少了类间的依赖：将对象之间复杂的网状通信结构简化为星型结构，降低了同事类之间的耦合度。
- 集中控制交互：将对象间的交互行为封装在中介者对象中，使得交互逻辑更易于理解、维护和修改。
- 符合迪米特法则：同事类只需要与中介者通信，不需要了解其他同事类。
- 提高了同事类的可复用性：由于同事类之间的耦合降低，它们更容易被复用。
- 提高了系统的灵活性和可扩展性：修改交互行为通常只需要修改中介者，而不需要修改各个同事类。
缺点：
- 中介者可能变得庞大复杂：如果系统中同事对象过多，或者交互逻辑过于复杂，中介者类可能会变得非常庞大，承担过多的责任，难以维护（演变成上帝类 God Object）。
- 增加了中介者类：引入了额外的中介者类，增加了系统的类数量。
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开发和需要解耦多个协作组件的系统中非常有用。
：健康跑步（附代码）)
的值？(受控组件))
等工具构建iOS应用稳定性与数据可观测体系)
)
：路径问题)
