如何使用Golang实现责任链+策略模式_组合请求处理逻辑

Go中“责任链+策略”组合模式的核心是Handler委托策略处理请求并按需传递：ChainHandler持HandlerStrategy实例，调用其Handle方法，根据返回结果决定是否终止或继续调用next。

用 Go 实现“责任链 + 策略”组合模式，核心是让每个处理器（Handler）既能按顺序传递请求（责任链），又能根据请求类型动态选择具体处理逻辑（策略）。这不是简单叠加两个模式，而是用策略解耦“怎么处理”，用责任链控制“谁来处理”。关键在于：处理器本身不硬编码业务逻辑，而是委托给可插拔的策略对象。

定义统一请求与策略接口

先抽象出请求数据结构和策略行为契约，这是组合的基础：

// 请求上下文，可携带任意字段
type Request struct {
    Type  string
    Data  map[string]interface{}
    Error error
}

// 策略接口：具体处理逻辑由实现者提供
type HandlerStrategy interface {
    Handle(req *Request) *Request
}

// 可选：带初始化能力的策略（如需依赖注入）
type InitializableStrategy interface {
    HandlerStrategy
    Init(config map[string]interface{}) error
}

构建可插拔的责任链节点

每个链节点（Handler）持有策略实例，并决定是否继续传递。它不关心策略内部怎么处理，只负责调用并判断是否中断链：

type ChainHandler struct {
    strategy HandlerStrategy
    next     *ChainHandler
}

func NewChainHandler(s HandlerStrategy) *ChainHandler {
    return &ChainHandler{strategy: s}
}

func (h *ChainHandler) SetNext(next *ChainHandler) {
    h.next = next
}

func (h *ChainHandler) Handle(req *Request) *Request {
    // 策略执行前可加通用逻辑（日志、校验等）
    if req.Error != nil {
        return req
    }

    // 委托给策略处理
    result := h.strategy.Handle(req)
    if result.Error != nil || h.shouldStop(result) {
        return result
    }

    // 继续传递（若存在下一节点）
    if h.next != nil {
        return h.next.Handle(result)
    }
    return result
}

// 可扩展：按返回值或请求状态决定是否终止链
func (h *ChainHandler) shouldStop(req *Request) bool {
    // 例如：策略显式返回 stop 标志，或 type 变更为 "done"
    if flag, ok := req.Data["stop_chain"]; ok && flag == true {
        return true
    }
    return false
}

实现具体策略并组装链

策略实现完全独立，便于单元测试和替换。链的组装发生在运行时，支持条件化插入：

• 写多个策略，比如 AuthStrategy、RateLimitStrategy、DBSaveStrategy
• 每个策略只专注一件事，不耦合其他环节
• 用工厂或配置驱动创建策略实例，避免 new 硬编码

示例策略：

type AuthStrategy struct {
    userDB *UserDB // 依赖可注入
}

func (a *AuthStrategy) Handle(req *Request) *Request {
    token := req.Data["token"].(string)
    if !a.userDB.Validate(token) {
        req.Error = fmt.Errorf("unauthorized")
        req.Data["stop_chain"] = true
    }
    return req
}

// 组装链（可读配置、DI 容器或代码硬编排）
auth := &AuthStrategy{userDB: newUserDB()}
rate := &RateLimitStrategy{limiter: newLimiter()}
save := &DBSaveStrategy{db: newDB()}

chain := NewChainHandler(auth)
chain.SetNext(NewChainHandler(rate)).SetNext(NewChainHandler(save))

// 使用
req := &Request{
    Type: "order_create",
    Data: map[string]interface{}{"token": "abc123", "order": "..."},
}
resp := chain.Handle(req)

增强灵活性：运行时策略路由

在责任链入口处加一层策略路由，根据请求类型分发到不同子链，进一步解耦：

type RouterChain struct {
    chains map[string]*ChainHandler // type → 子链
}

func (r *RouterChain) Handle(req *Request) *Request {
    handler, ok := r.chains[req.Type]
    if !ok {
        req.Error = fmt.Errorf("no handler for type: %s", req.Type)
        return req
    }
    return handler.Handle(req)
}

// 使用：为不同业务类型挂不同责任链
router := &RouterChain{
    chains: map[string]*ChainHandler{
        "payment": NewChainHandler(&PayAuth{}).SetNext(NewChainHandler(&PayLog{})),
        "notify":  NewChainHandler(&NotifyRetry{}).SetNext(NewChainHandler(&NotifyPush{})),
    },
}

这种组合让系统既保持流程可控（链式顺序），又具备高度可扩展性（策略即插即用），还利于测试和演进——改策略不影响链结构，增节点不改策略逻辑。