当前位置：首页 > 文章列表 > Golang > Go教程 > Golang中介者模式实战解耦交互

Golang中介者模式实战解耦交互

2025-11-25 19:35:32 0浏览收藏

在复杂的Golang系统中，对象间直接通信易导致高度耦合。**Golang中介者模式**通过引入中介者对象，集中管理组件交互，实现解耦，提升系统可维护性。本文以聊天室为例，深入探讨中介者模式的实践应用：用户（同事类）通过ChatServer（具体中介者）发送消息，避免直接引用其他用户，降低耦合。文章将详细介绍中介者模式的结构，包括定义通信接口的Mediator、管理用户并转发消息的ConcreteMediator以及通过中介者收发消息的Colleague。此外，还将分析中介者模式的优势与适用场景，如聊天系统、UI联动等，并探讨其潜在问题及注意事项，助你掌握如何在Golang项目中有效运用中介者模式，构建更清晰、更易扩展的代码。

中介者模式通过引入中介者对象集中管理组件交互，实现解耦。在Golang聊天室示例中，用户通过ChatServer发送消息，避免直接引用其他用户，降低耦合，提升可维护性。1. 中介者（ChatMediator）定义通信接口；2. 具体中介者（ChatServer）管理用户并转发消息；3. 同事类（User）通过中介者收发消息，不直接通信。该模式适用于聊天系统、UI联动等场景，但需防中介者过度膨胀。

Golang如何实现中介者模式解耦对象交互_Golang 中介者模式应用实践

在复杂系统中，多个对象之间直接通信会导致高度耦合，难以维护和扩展。Golang 中通过中介者模式（Mediator Pattern）可以有效解耦对象间的交互逻辑。该模式的核心思想是引入一个“中介者”对象，集中处理对象之间的通信，让各个组件不再相互引用，而是通过中介者进行消息传递。

中介者模式的基本结构

中介者模式包含以下几个关键角色：

Mediator（中介者）：定义统一接口，用于各组件之间的通信协调。
ConcreteMediator（具体中介者）：实现中介者接口，管理多个组件实例，并协调它们的交互。
Colleague（同事类 / 组件）：每个组件持有对中介者的引用，不直接与其他组件通信，而是通过中介者发送和接收消息。

这种结构特别适用于如聊天室、UI组件联动、游戏对象交互等场景。

用 Golang 实现一个聊天室示例

假设我们正在构建一个简单的多人聊天室，用户（User）不能直接向其他用户发送消息，必须通过聊天服务器（ChatServer）中转。这就是典型的中介者应用场景。

package main

// Mediator interface
type ChatMediator interface {
    SendMessage(message string, user User)
}

// ConcreteMediator
type ChatServer struct {
    users []User
}

func (c *ChatServer) AddUser(user User) {
    c.users = append(c.users, user)
}

func (c *ChatServer) SendMessage(message string, sender User) {
    for _, user := range c.users {
        // 不向发送者自己转发消息
        if user.GetName() != sender.GetName() {
            user.Receive(message)
        }
    }
}

// Colleague interface
type User interface {
    GetName() string
    Send(message string)
    Receive(message string)
}

// Concrete colleague
type ChatUser struct {
    name     string
    mediator ChatMediator
}

func NewChatUser(name string, mediator ChatMediator) *ChatUser {
    return &ChatUser{
        name:     name,
        mediator: mediator,
    }
}

func (u *ChatUser) GetName() string {
    return u.name
}

func (u *ChatUser) Send(message string) {
    println(u.name + " 发送消息: " + message)
    u.mediator.SendMessage(message, u)
}

func (u *ChatUser) Receive(message string) {
    println(u.name + " 收到消息: " + message)
}

// 示例使用
func main() {
    server := &ChatServer{}

    alice := NewChatUser("Alice", server)
    bob := NewChatUser("Bob", server)
    charlie := NewChatUser("Charlie", server)

    server.AddUser(alice)
    server.AddUser(bob)
    server.AddUser(charlie)

    alice.Send("大家好，我是 Alice！")
    bob.Send("Hi，我是 Bob。")
}

运行结果会显示每个用户发送的消息被其他用户接收，但用户之间没有直接依赖。所有通信都由 ChatServer 统一调度。