如何使用Golang实现责任链模式_使用Chain of Responsibility处理请求链

Go中责任链模式通过HandlerFunc函数类型和Chain结构实现，以组合代替继承，支持日志、鉴权等Handler链式包装与动态中断。

用 Go 实现责任链模式，核心是让多个处理器（Handler）按顺序尝试处理请求，每个 Handler 决定是否处理、是否继续传递。Go 没有继承机制，但靠接口 + 组合 + 函数式风格能更轻量、更灵活地实现它。

定义统一的处理器接口

所有 Handler 都要实现同一个行为：接收请求、返回响应或错误，并决定是否把请求传给下一个 Handler。

推荐用函数类型代替接口，更简洁：

type HandlerFunc func(req interface{}) (resp interface{}, err error)

再封装一个链式调用结构：

type Chain struct { handlers []HandlerFunc }

构建可串联的 Handler 链

每个 Handler 只关心自己的逻辑，处理完后手动调用 next（如果存在）——这比“强制继承 BaseHandler”更符合 Go 的组合哲学。

例如写一个日志 Handler 和一个鉴权 Handler：

func LoggingHandler(next HandlerFunc) HandlerFunc {
  return func(req interface{}) (interface{}, error) {
    log.Println("→ request received:", req)
    resp, err := next(req)
    log.Println("← response sent:", resp)
    return resp, err
  }
} func AuthHandler(next HandlerFunc) HandlerFunc {
  return func(req interface{}) (interface{}, error) {
    if user, ok := req.(map[string]interface{})["user"]; !ok || user == nil {
      return nil, errors.New("unauthorized")
    }
    return next(req)
  }
}

组装与执行链

链的组装建议从后往前（类似中间件），让最内层 Handler 先定义，再逐层包装：

• 先写业务 Handler（比如处理支付逻辑）
• 用 AuthHandler 包一层
• 再用 LoggingHandler 包一层
• 最后调用顶层 Handler 处理请求

示例：

payHandler := func(req interface{}) (interface{}, error) {
  return map[string]string{"status": "paid"}, nil
}

chain := LoggingHandler(AuthHandler(payHandler))
resp, err := chain(map[string]interface{}{"user": "alice", "amount": 100})

支持动态插拔与中断

如果需要运行时增删 Handler，可用切片维护 handler 列表，配合 for 循环+break 实现中断：

func (c *Chain) Serve(req interface{}) (interface{}, error) {
  for _, h := range c.handlers {
    if resp, err := h(req); err != nil {
      return resp, err // 中断链
    } else if resp != nil {
      return resp, nil // 显式返回，不继续
    }
  }
  return nil, errors.New("no handler processed the request")
}

这样既保留控制权，又避免隐式跳转，调试也更直观。

基本上就这些。Go 里责任链不靠类继承，而靠函数包装和显式调用，反而更可控、易测试、无耦合。