Go中可动态调整的责任链通过接口+组合+函数式设计实现：定义Handler接口统一调用，BaseHandler嵌入复用逻辑，Chain结构体支持运行时增删改查节点，并用FuncHandler适配闭包逻辑。
在 Go 中实现可动态调整的责任链（Chain of Responsibility），关键在于解耦处理器、支持运行时增删节点、避免硬编码链式结构。Go 本身没有类继承和接口强制实现，但通过接口+组合+函数式设计，能优雅达成目标。
定义统一的处理器接口
所有处理节点需实现同一接口，确保链式调用兼容性：
type Handler interface {
Handle(ctx context.Context, req interface{}) (interface{}, error)
SetNext(next Handler) Handler // 支持链式设置下一节点
}
注意：SetNext 返回 Handler 是为了支持链式构建（如 h1.SetNext(h2).SetNext(h3)），也便于动态重连。
实现可插拔的基础处理器结构
用嵌入方式复用通用逻辑，每个具体处理器只专注自身职责：
立即学习“go语言免费学习笔记（深入）”；
type BaseHandler struct {
next Handler
}
func (b *BaseHandler) SetNext(next Handler) Handler {
b.next = next
return next
}
func (b *BaseHandler) Next() Handler {
return b.next
}
// 默认委托给下一个处理器（可被子类覆盖）
func (b *BaseHandler) Handle(ctx context.Context, req interface{}) (interface{}, error) {
if b.next != nil {
return b.next.Handle(ctx, req)
}
return nil, fmt.Errorf("no handler available")
}
实际业务处理器只需匿名嵌入 BaseHandler，并重写 Handle 方法：
- 鉴权处理器：检查 token，合法则放行，否则返回错误
- 限流处理器：检查请求速率，超限则返回 429
- 日志处理器：记录请求耗时与结果，再转发
运行时动态管理责任链
不依赖初始化时固定构造，而是提供注册、插入、移除、替换等操作：
type Chain struct {
head Handler
mu sync.RWMutex
}
func (c *Chain) Add(h Handler) {
c.mu.Lock()
defer c.mu.Unlock()
if c.head == nil {
c.head = h
} else {
// 找到最后一个节点并追加
tail := c.findTail(c.head)
tail.SetNext(h)
}
}
func (c *Chain) InsertBefore(targetName string, newHandler Handler, nameGetter func(Handler) string) {
c.mu.Lock()
defer c.mu.Unlock()
// 遍历链表，找到 target 前一节点，重连指针
// （具体实现略，核心是修改 next 指针）
}
func (c *Chain) Remove(name string, nameGetter func(Handler) string) {
c.mu.Lock()
defer c.mu.Unlock()
// 断开匹配节点，跳过它
}
func (c *Chain) Serve(ctx context.Context, req interface{}) (interface{}, error) {
c.mu.RLock()
defer c.mu.RUnlock()
if c.head == nil {
return nil, errors.New("empty chain")
}
return c.head.Handle(ctx, req)
}
典型使用场景：
- 灰度发布：临时插入一个 A/B 路由处理器到链中某位置
- 故障隔离：检测到下游异常，动态移除缓存处理器，直连数据库
- 调试模式：运行时注入 DebugLogHandler 到链首或链尾
用函数式处理器简化轻量逻辑
对简单逻辑（如日志、指标），无需定义结构体，直接用闭包封装：
func WithLogging(next Handler) Handler {
return &FuncHandler{fn: func(ctx context.Context, req interface{}) (interface{}, error) {
start := time.Now()
resp, err := next.Handle(ctx, req)
log.Printf("req=%v, took=%v, err=%v", req, time.Since(start), err)
return resp, err
}}
}
// 函数适配器
type FuncHandler struct {
fn func(context.Context, interface{}) (interface{}, error)
next Handler
}
func (f *FuncHandler) SetNext(h Handler) Handler {
f.next = h
return h
}
func (f *FuncHandler) Handle(ctx context.Context, req interface{}) (interface{}, error) {
return f.fn(ctx, req)
}
这样就能写出干净链式调用：
chain := &Chain{}
chain.Add(AuthHandler{})
chain.Add(WithLogging(WithMetrics(RateLimitHandler{})))
// 后续还可随时 chain.Remove("AuthHandler")
基本上就这些。Go 的责任链不靠继承靠组合，不靠配置靠代码控制，动态性来自显式指针管理和并发安全的链表操作。重点不是“怎么连”，而是“怎么安全地重连”。
