如何用Golang实现责任链与过滤器链结合_Golang 责任链模式高级实践

顺亿

2026-09-27 • 👁 0人浏览过

文章介绍了Golang中责任链模式与过滤器链的结合应用，用于构建灵活的请求处理流程；2. 通过定义Handler接口和FilterChain切片实现链式调用，每个处理器可决定是否处理请求或转发；3. 示例展示了日志、认证、参数校验处理器的顺序执行；4. 支持AroundHandler形式的双向拦截，通过适配器兼容原链，实现如耗时统计等环绕逻辑；5. 最终强调该设计在中间件系统中的高扩展性与解耦优势。在Golang中，责任链模式与过滤器链的结合可以构建灵活、可扩展的请求处理流程。这种设计常见于中间件系统（如Web框架中的HTTP处理）、权限校验、日志记录、数据预处理等场景。通过将每个处理步骤抽象为独立节点，既能解耦逻辑，又能动态组合行为。责任链与过滤器链的基本概念责任链模式：多个处理器依次构成一条链，每个处理器决定是否处理请求或传递给下一个。典型特征是“一个请求被多个对象尝试处理”。过滤器链（Filter Chain）：类似于责任链，但更强调对同一请求的层层加工与流转，常用于前置处理、转换、验证等操作，最终到达终点处理器。两者结合时，每个节点既是责任处理器，也是过滤器，可以在请求进入和响应返回两个阶段起作用。立即学习 “ go语言免费学习笔记（深入） ”；定义通用处理器接口为了统一管理链式结构，先定义一个处理器接口：

type Handler interface {
    Handle(request *Request, response *Response, chain FilterChain) error
}
type FilterChain []Handler

func (fc FilterChain) Proceed(request Request, response Response) error { if len(fc) == 0 { return nil // 到达链尾 } head := fc[0] tail := fc[1:] return head.Handle(request, response, tail) }

这里

FilterChain

是一个处理器切片，

Proceed

方法取出第一个处理器执行，并传入剩余链段，实现递归调用。实现具体处理器示例假设我们要构建一个API请求处理流程，包含日志记录、身份验证、参数校验三个步骤： go语言参考手册中文CHM版 Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。本文给大家带来Go参考手册，需要的可以来下载！ Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。 Go 语言特色简洁、快速、安全并行、有趣、开源内存管理、v数组安全、编译下载

// 日志处理器
type LoggingHandler struct{}
func (l LoggingHandler) Handle(req Request, resp *Response, chain FilterChain) error {
fmt.Println("开始处理请求:", req.Path)
err := chain.Proceed(req, resp)
fmt.Println("请求处理完成，状态:", resp.Status)
return err
}
// 身份验证处理器
type AuthHandler struct{}
func (a AuthHandler) Handle(req Request, resp *Response, chain FilterChain) error {
if req.Headers["Authorization"] == "" {
resp.Status = 401
resp.Body = "Unauthorized"
return nil // 不继续向下传递
}
return chain.Proceed(req, resp)
}
// 参数校验处理器
type ValidationHandler struct{}

func (v ValidationHandler) Handle(req Request, resp *Response, chain FilterChain) error { if req.Body == "" { resp.Status = 400 resp.Body = "Bad Request: missing body" return nil } return chain.Proceed(req, resp) }

使用链式结构组装流程现在我们可以将这些处理器按顺序组合成一条链：

type Request struct {
    Path    string
    Headers map[string]string
    Body    string
}
type Response struct {
Status int
Body   string
}
func main() {
request := &Request{
Path:    "/api/v1/data",
Headers: map[string]string{"Authorization": "token-123"},
Body:    {"key":"value"},
}
response := &Response{}

chain := FilterChain{
    &LoggingHandler{},
    &AuthHandler{},
    &ValidationHandler{},
}

err := chain.Proceed(request, response)
if err != nil {
    fmt.Println("处理出错:", err)
}
fmt.Printf("响应: %d - %s\n", response.Status, response.Body)

} 输出结果会显示完整的处理流程，包括日志打印、认证通过、参数有效，并最终完成请求。支持双向拦截的进阶结构有些场景需要在前后都插入逻辑（类似AOP环绕通知），可以改进

Handle

函数结构：

type AroundHandler func(
    req *Request,
    resp *Response,
    next func() error,
) error

然后封装一个适配器使其兼容原链：

func Adapt(fn AroundHandler) Handler {
    return &adapter{fn}
}
type adapter struct {
fn AroundHandler
}

func (a adapter) Handle(req Request, resp *Response, chain FilterChain) error { return a.fn(req, resp, func() error { return chain.Proceed(req, resp) }) }

这样就可以写更复杂的中间件，比如测量耗时：

timing := Adapt(func(req *Request, resp *Response, next func() error) error {
    start := time.Now()
    err := next()
    fmt.Printf("处理耗时: %v\n", time.Since(start))
    return err
})

基本上就这些。通过接口抽象、函数式扩展和链式调用，Golang能优雅地实现责任链与过滤器链的融合，既保持简洁又不失灵活性。关键在于定义清晰的执行契约，并允许自由组合与嵌套。

相关文章