文章介绍了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请求处理流程，包含日志记录、身份验证、参数校验三个步骤：
// 日志处理器
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能优雅地实现责任链与过滤器链的融合，既保持简洁又不失灵活性。关键在于定义清晰的执行契约，并允许自由组合与嵌套。
