如何在Golang中实现观察者+命令模式_事件驱动执行请求-Golang-PHP中文网

Go中通过接口定义Command并结合EventBus实现观察者+命令模式组合，用闭包将命令绑定为事件处理器，支持同步/异步执行、撤销、日志与测试。

如何在golang中实现观察者+命令模式_事件驱动执行请求

在 Go 中实现“观察者 + 命令模式”组合以支持事件驱动的请求执行，核心是解耦事件产生者（Subject）与响应者（Observer），同时让每个响应动作封装为可调度、可撤销、可记录的命令（Command）。这不是简单套用两个设计模式，而是利用 Go 的接口、闭包和 channel 特性，构建轻量、类型安全、易于测试的事件处理链。

定义命令接口与具体命令

命令模式的关键是统一行为契约。Go 中用接口表达最自然：

type Command interface {
    Execute() error
    Undo() error // 可选：支持回滚
    Name() string
}

例如一个用户注册请求可封装为命令：

type RegisterUserCmd struct {
    Email, Password string
    UserID          int
    Store           UserStore // 依赖注入，便于测试
}
<p>func (c *RegisterUserCmd) Execute() error {
user := User{Email: c.Email, Password: c.Password}
id, err := c.Store.Create(user)
c.UserID = id
return err
}</p><p>func (c *RegisterUserCmd) Undo() error {
return c.Store.Delete(c.UserID)
}</p><p>func (c *RegisterUserCmd) Name() string { return "RegisterUser" }</p>

构建事件总线（观察者核心）

用泛型 map + sync.RWMutex 实现线程安全的事件注册/通知机制，事件类型用字符串或自定义类型（推荐枚举）：

type Event string
<p>const (
EventUserRegistered Event = "user.registered"
EventPaymentProcessed Event = "payment.processed"
)</p><p>type EventBus struct {
mu       sync.RWMutex
handlers map[Event][]func(interface{}) error
}</p><p>func NewEventBus() *EventBus {
return &EventBus{
handlers: make(map[Event][]func(interface{}) error),
}
}</p><p>func (eb *EventBus) Subscribe(event Event, handler func(interface{}) error) {
eb.mu.Lock()
defer eb.mu.Unlock()
eb.handlers[event] = append(eb.handlers[event], handler)
}</p><p>func (eb *EventBus) Publish(event Event, payload interface{}) error {
eb.mu.RLock()
handlers := make([]func(interface{}) error, len(eb.handlers[event]))
copy(handlers, eb.handlers[event])
eb.mu.RUnlock()</p><pre class="brush:php;toolbar:false;">var errs []error
for _, h := range handlers {
    if err := h(payload); err != nil {
        errs = append(errs, err)
    }
}
if len(errs) > 0 {
    return fmt.Errorf("event %s failed: %v", event, errs)
}
return nil

}

MFA WORD

强制使用密钥词进行 MFA 以访问敏感数据，支持超级密钥词紧急重置。

下载

连接命令与事件：命令作为事件处理器

让命令本身成为观察者——即把 Execute() 绑定到事件总线。更灵活的做法是用工厂函数生成 handler：

// 创建命令执行器（handler 工厂）
func MakeCommandHandler(cmd Command) func(interface{}) error {
    return func(payload interface{}) error {
        // 可在此做 payload 转换、校验、日志等
        log.Printf("Executing command: %s", cmd.Name())
        return cmd.Execute()
    }
}
<p>// 使用示例
bus := NewEventBus()
bus.Subscribe(EventUserRegistered, MakeCommandHandler(&RegisterUserCmd{
Email: "a@b.com",
Store: &MockUserStore{},
}))</p><p>// 触发事件 → 自动执行命令
bus.Publish(EventUserRegistered, nil)</p>

这样既保持命令的独立性，又通过闭包将其接入事件流。你还可以包装成带重试、超时、事务的增强 handler。