如何使用Golang实现责任链动态调整_使用Chain of Responsibility管理请求

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)），也便于动态重连。

实现可插拔的基础处理器结构

用嵌入方式复用通用逻辑，每个具体处理器只专注自身职责：

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 的责任链不靠继承靠组合，不靠配置靠代码控制，动态性来自显式指针管理和并发安全的链表操作。重点不是“怎么连”，而是“怎么安全地重连”。