Golang用channel实现中介者模式解耦通信

Go语言中可通过channel实现中介者模式以降低模块耦合度。其核心步骤为：定义事件类型和中介者结构，各模块通过channel发送事件，中介者统一处理事件并响应。具体而言：1. 定义Event结构体表示消息类型；2. 创建Mediator结构体并包含eventChan通道；3. 各模块向eventChan发送事件而不直接相互调用；4. Mediator监听通道并根据事件类型执行对应逻辑；5. 使用时注意设置channel缓冲、错误恢复、生命周期管理及保持中介者职责单一。例如登录模块发送"user_login"事件后，中介者触发通知模块完成解耦。此外还需添加recover机制防止协程崩溃，并在程序退出时关闭channel避免泄漏。

在Go语言中，中介者模式可以通过channel来很好地实现。它的核心思想是通过一个中间结构体（或协程）来协调多个模块之间的通信，从而降低模块之间的耦合度。相比传统的直接调用方式，使用channel可以更自然地配合goroutine进行异步处理，让系统结构更清晰、可维护性更高。

下面我们就来看看几种常见的实现方式和使用场景。

中介者的基本结构设计

要实现中介者模式，首先需要定义一个“中介者”角色，它负责接收来自各个模块的消息，并决定如何转发或处理这些消息。

通常的做法是：

• 定义不同的消息类型（比如结构体）
• 创建一个中介者的结构体，里面包含多个channel
• 各个模块只与中介者通信，不直接相互调用

举个例子，你可以为事件注册一个channel，每个模块都向这个channel发送自己的事件，而中介者则监听这个channel并根据事件类型做出响应。

type Event struct {
    Type string
    Data interface{}
}

type Mediator struct {
    eventChan chan Event
}

func NewMediator() *Mediator {
    return &Mediator{
        eventChan: make(chan Event, 10),
    }
}

func (m *Mediator) Start() {
    go func() {
        for event := range m.eventChan {
            // 根据event.Type做相应处理
            fmt.Printf("Handling event: %s\n", event.Type)
        }
    }()
}

模块通过channel向中介者发送消息

各模块只需要持有中介者的channel引用，就可以发送消息，不需要知道其他模块的存在。

举个实际的例子：假设有一个用户登录模块和一个通知模块。登录完成后要触发通知，但不想让登录模块直接依赖通知模块。

做法是：

• 登录模块完成登录后，向中介者的channel发送一个"user_login"事件
• 中介者监听到该事件后，再触发通知逻辑

这样就实现了模块间的解耦。

具体代码如下：

// 登录模块
func LoginUser(mediator *Mediator) {
    // 模拟登录操作
    fmt.Println("User logged in")
    mediator.eventChan <- Event{Type: "user_login", Data: "user123"}
}

// 中介者处理逻辑中增加判断
func (m *Mediator) Start() {
    go func() {
        for event := range m.eventChan {
            switch event.Type {
            case "user_login":
                NotifyUser(event.Data.(string))
            }
        }
    }()
}

// 通知模块
func NotifyUser(userID string) {
    fmt.Printf("Sending notification to user: %s\n", userID)
}

使用中介者时需要注意的问题

虽然中介者模式能有效解耦模块，但在实际使用中也有一些容易忽略的细节：

• Channel容量：如果事件频繁，建议设置一定的缓冲大小，避免阻塞发送方。
• 错误处理：中介者协程崩溃会导致整个通信机制失效，最好加上recover机制。
• 生命周期管理：如果程序有退出流程，记得关闭channel，防止goroutine泄漏。
• 职责单一：中介者本身不要承担太多业务逻辑，保持其“路由+转发”的职责。

举个简单的recover示例：

func (m *Mediator) Start() {
    go func() {
        defer func() {
            if r := recover(); r != nil {
                fmt.Println("Recovered in mediator:", r)
            }
        }()
        for event := range m.eventChan {
            // 处理事件
        }
    }()
}

总结一下

用Golang实现中介者模式的核心就是利用channel和goroutine构建一个中间层，让模块之间不再直接通信。这种方式不仅符合Go的并发模型，还能提升系统的可扩展性和可测试性。

实现上主要分三步走：

• 定义事件类型和中介者结构
• 各模块通过channel发送事件
• 中介者统一处理事件并做响应

基本上就这些。只要注意channel的使用方式和中介者的健壮性，就能写出一个不错的中介者实现。