Mediator模式通过引入中介者对象封装对象间交互，降低耦合。Go中以接口定义通信规则，结构体组合实现具体逻辑，如聊天室系统中用户通过中介发送消息，彼此无直接依赖，提升可维护性与扩展性。
在 Go 语言中，Mediator（中介者）模式用于封装一组对象之间的交互方式，避免对象之间直接引用，从而降低耦合度。通过引入一个中介者对象统一处理对象间的通信，使得组件更易于维护和扩展。
Mediator 模式的结构
Mediator 模式包含以下几个核心角色：
- Mediator：定义同事对象之间通信的接口。
- ConcreteMediator：实现 Mediator 接口，协调各个同事对象的交互逻辑。
- Colleague：同事对象持有对中介者的引用，通过中介者与其他同事通信。
- ConcreteColleague：具体的同事类，发送和接收消息。
实际示例：聊天室系统
以一个简单的聊天室为例，多个用户（User）不直接互相发送消息，而是通过聊天室（ChatRoom）这个中介者进行通信。
package main
import "fmt"
// Mediator 接口
type ChatMediator interface {
SendMessage(message string, user User)
}
// ConcreteMediator：聊天室
type ChatRoom struct {
users []User
}
func (cr *ChatRoom) AddUser(user User) {
cr.users = append(cr.users, user)
}
func (cr *ChatRoom) SendMessage(message string, sender User) {
for _, user := range cr.users {
// 不向发送者本人转发消息
if user != sender {
user.Receive(message)
}
}
}
// Colleague 接口
type User interface {
Send(message string)
Receive(message string)
}
// ConcreteColleague：具体用户
type ChatUser struct {
name string
mediator ChatMediator
}
func NewChatUser(name string, mediator ChatMediator) *ChatUser {
return &ChatUser{
name: name,
mediator: mediator,
}
}
func (u *ChatUser) Send(message string) {
fmt.Printf("[%s 发送]: %s\n", u.name, message)
u.mediator.SendMessage(message, u)
}
func (u *ChatUser) Receive(message string) {
fmt.Printf("[%s 收到]: %s\n", u.name, message)
}
// 使用示例
func main() {
chatRoom := &ChatRoom{}
alice := NewChatUser("Alice", chatRoom)
bob := NewChatUser("Bob", chatRoom)
charlie := NewChatUser("Charlie", chatRoom)
chatRoom.AddUser(alice)
chatRoom.AddUser(bob)
chatRoom.AddUser(charlie)
alice.Send("大家好，我是 Alice！")
bob.Send("Hi，我是 Bob。")
charlie.Send("Charlie 在线。")
}
输出结果说明
运行上述代码将得到如下输出：
立即学习“go语言免费学习笔记（深入）”；
[Alice 发送]: 大家好，我是 Alice！ [Bob 收到]: 大家好，我是 Alice！ [Charlie 收到]: 大家好，我是 Alice！ [Bob 发送]: Hi，我是 Bob。 [Alice 收到]: Hi，我是 Bob。 [Charlie 收到]: Hi，我是 Bob。 [Charlie 发送]: Charlie 在线。 [Alice 收到]: Charlie 在线。 [Bob 收到]: Charlie 在线。
可以看到，每个用户只与 ChatRoom 通信，彼此之间没有直接依赖。
优势与适用场景
使用中介者模式的好处包括：
- 减少对象间的直接依赖，提升模块独立性。
- 集中控制交互逻辑，便于修改和测试。
- 适用于多个对象频繁通信的场景，如 GUI 组件、事件总线、聊天系统等。
在 Golang 中，由于没有继承机制，我们通过接口和组合来实现该模式，简洁且符合 Go 的设计哲学。
基本上就这些。通过接口抽象和结构体组合，Go 能很自然地实现中介者模式，让组件交互更清晰可控。
