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

type Handler interface {
    Handle(ctx context.Context, req interface{}) (interface{}, error)
    SetNext(next Handler) Handler // 支持链式设置下一节点
}

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")
}

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)
}

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")