Go语言中责任链模式通过接口定义Handler，使用组合与函数式编程实现灵活的处理器链，支持动态组装日志、限流、认证等中间件，请求依次传递直至被处理，适用于HTTP中间件、多级校验等场景。
在 Go 语言中实现责任链模式，核心是让多个处理器（Handler）按顺序尝试处理请求，每个处理器决定是否处理或把请求传递给下一个。Go 没有类继承，但通过接口 + 组合 + 函数式风格能简洁、高效地实现该模式，且天然契合其并发与中间件场景（如 HTTP 中间件、日志、鉴权等）。
定义统一的 Handler 接口
所有处理器都实现同一个接口，接收请求并返回是否已处理（或继续传递）：
// Request 可以是任意结构体，这里用简单字符串示意
// Handler 是责任链中的节点，返回 true 表示已处理，不再向后传递
type Handler interface {
Handle(request string) bool
}
构建可链式组装的处理器类型
用结构体封装具体逻辑，并支持设置“下一个处理器”，形成链式调用能力：
type AuthHandler struct {
next Handler
}
func (h *AuthHandler) Handle(request string) bool {
if strings.Contains(request, "token=valid") {
fmt.Println("✅ 认证通过")
return true // 终止链
} else {
fmt.Println("❌ 认证失败，交由下一环节")
if h.next != nil {
return h.next.Handle(request)
}
}
return false
}
func (h *AuthHandler) SetNext(next Handler) { h.next = next }
支持函数式 Handler（更 Go 风格）
用函数类型替代结构体，提升灵活性和可读性：
立即学习“go语言免费学习笔记（深入）”；
type HandlerFunc func(string) bool
func (f HandlerFunc) Handle(request string) bool { return f(request) }
// 快速创建一个日志 Handler
logger := HandlerFunc(func(r string) bool {
fmt.Printf("[LOG] 收到请求: %s\n", r)
return false // 不终止，继续传递
})
// 创建限流 Handler
limiter := HandlerFunc(func(r string) bool {
if len(r) > 100 {
fmt.Println("⚠️ 请求超长，拒绝")
return true
}
return false
})
组装与执行链（支持动态顺序）
把 Handler 串成链，然后调用首个节点即可：
// 按需组装：日志 → 限流 → 认证 → 业务处理
chain := logger
chain = Chain(chain, limiter)
chain = Chain(chain, &AuthHandler{})
chain = Chain(chain, HandlerFunc(func(r string) bool {
fmt.Println("? 执行核心业务逻辑")
return true
}))
// 工具函数：将 a 和 b 连接为 a → b
func Chain(a, b Handler) Handler {
if h, ok := a.(interface{ SetNext(Handler) }); ok {
h.SetNext(b)
return a
} else if f, ok := a.(HandlerFunc); ok {
return HandlerFunc(func(r string) bool {
if f(r) { return true }
return b.Handle(r)
})
}
return a
}
// 触发处理
chain.Handle("token=valid&user=admin")
基本上就这些。Go 的责任链不依赖继承，靠接口统一行为、组合管理流程、函数式增强表达力，写起来轻量，读起来清晰，特别适合中间件、过滤器、多级校验等场景。
