文章介绍了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
}
<p>type FilterChain []Handler</p><p>func (fc FilterChain) Proceed(request <em>Request, response </em>Response) error {
if len(fc) == 0 {
return nil // 到达链尾
}
head := fc[0]
tail := fc[1:]
return head.Handle(request, response, tail)
}这里FilterChain是一个处理器切片，Proceed方法取出第一个处理器执行，并传入剩余链段，实现递归调用。
实现具体处理器示例
假设我们要构建一个API请求处理流程，包含日志记录、身份验证、参数校验三个步骤：
使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等
// 日志处理器
type LoggingHandler struct{}
<p>func (l <em>LoggingHandler) Handle(req </em>Request, resp *Response, chain FilterChain) error {
fmt.Println("开始处理请求:", req.Path)
err := chain.Proceed(req, resp)
fmt.Println("请求处理完成，状态:", resp.Status)
return err
}</p><p>// 身份验证处理器
type AuthHandler struct{}</p><p>func (a <em>AuthHandler) Handle(req </em>Request, resp *Response, chain FilterChain) error {
if req.Headers["Authorization"] == "" {
resp.Status = 401
resp.Body = "Unauthorized"
return nil // 不继续向下传递
}
return chain.Proceed(req, resp)
}</p><p>// 参数校验处理器
type ValidationHandler struct{}</p><p>func (v <em>ValidationHandler) Handle(req </em>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
}
<p>type Response struct {
Status int
Body string
}</p><p>func main() {
request := &Request{
Path: "/api/v1/data",
Headers: map[string]string{"Authorization": "token-123"},
Body: <code>{"key":"value"}</code>,
}
response := &Response{}</p><pre class="brush:php;toolbar:false;">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}
}
<p>type adapter struct {
fn AroundHandler
}</p><p>func (a <em>adapter) Handle(req </em>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能优雅地实现责任链与过滤器链的融合，既保持简洁又不失灵活性。关键在于定义清晰的执行契约，并允许自由组合与嵌套。
