责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许多个对象有机会处理请求，从而避免请求的发送者和接收者之间的耦合。在 Go 语言中，由于其简洁的接口和结构体组合机制，实现责任链非常直观且高效。
责任链模式的核心思想
将多个处理器串联成一条链，请求沿着这条链传递，直到某个处理器处理它为止。每个处理器都有机会处理请求，也可以选择将其传递给下一个处理器。
这种模式常用于日志处理、权限校验、中间件系统等场景。
定义处理器接口
在 Go 中，我们可以通过接口来定义处理器的标准行为：
type Handler interface {
SetNext(handler Handler)
Handle(request string) string
}
每个处理器需要实现 SetNext 方法来设置下一个处理器，并通过 Handle 方法处理请求。如果当前处理器无法处理，就交给下一个。
实现具体的处理器
以一个简单的审批流程为例：有三个角色——组长、经理、总监，分别处理不同级别的请求。
type TeamLeader struct {
next Handler
}
func (t *TeamLeader) SetNext(handler Handler) {
t.next = handler
}
func (t *TeamLeader) Handle(request string) string {
if request == "minor" {
return "TeamLeader: 处理了小问题"
}
if t.next != nil {
return t.next.Handle(request)
}
return "无人处理"
}
}
func (t *TeamLeader) Handle(request string) string {
if request == "minor" {
return "TeamLeader: 处理了小问题"
}
if t.next != nil {
return t.next.Handle(request)
}
return "无人处理"
}类似地，可以实现 Manager 和 Director：
type Manager struct {
next Handler
}
func (m *Manager) SetNext(handler Handler) {
m.next = handler
}
func (m *Manager) Handle(request string) string {
if request == "medium" {
return "Manager: 处理了中等问题"
}
if m.next != nil {
return m.next.Handle(request)
}
return "无人处理"
}
type Director struct {
next Handler
}
func (d *Director) SetNext(handler Handler) {
d.next = handler
}
func (d *Director) Handle(request string) string {
if request == "major" {
return "Director: 处理了重大问题"
}
if d.next != nil {
return d.next.Handle(request)
}
return "无人处理"
}
构建和使用责任链
现在我们可以把这三个处理器串成一条链：
func main() {
teamLeader := &TeamLeader{}
manager := &Manager{}
director := &Director{}
// 组装链条
teamLeader.SetNext(manager)
manager.SetNext(director)
// 发起请求
println(teamLeader.Handle("minor")) // TeamLeader 处理
println(teamLeader.Handle("medium")) // Manager 处理
println(teamLeader.Handle("major")) // Director 处理
println(teamLeader.Handle("unknown")) // 无人处理
}
输出结果：
TeamLeader: 处理了小问题 Manager: 处理了中等问题 Director: 处理了重大问题 无人处理
实际应用场景建议
责任链在 Web 框架中间件中特别常见。比如 Gin 或 Echo 的中间件机制本质上就是责任链：
- 身份认证中间件先检查 token
- 日志中间件记录访问信息
- 限流中间件控制请求频率
每一个中间件都可以决定是否继续调用下一个（c.Next()），这正是责任链的体现。
自定义中间件时，可以用类似的结构组织逻辑，保持解耦和可扩展性。
基本上就这些。Go 的接口和组合特性让责任链实现干净利落，无需复杂继承体系，适合构建灵活的处理流程。
