Go语言虽无语法级装饰器，但可通过接口+高阶函数实现链式装饰器模式：定义统一Handler接口，各装饰器接收并返回Handler，支持参数化构造与线性Chain组装，结合泛型可提升类型安全。
Go 语言本身不支持像 Python 那样的语法级装饰器（@decorator），但可以通过函数式编程 + 接口 + 高阶函数，优雅地实现**装饰器模式的链式调用**，达到“叠加功能”的效果。核心思路是：让每个装饰器接收一个符合某接口的处理器（如 Handler），返回一个增强后的新处理器，从而形成可组合、可复用的中间件链。
定义统一的处理接口
这是链式装饰的基础。通常用一个函数类型或接口封装“处理逻辑”：
type Handler func(ctx context.Context, req interface{}) (interface{}, error)
// 或更通用的接口（推荐，便于 mock 和扩展）
type Handler interface {
Handle(ctx context.Context, req interface{}) (interface{}, error)
}只要所有装饰器和原始处理器都遵循这个契约，就能自由拼接。
编写可链式叠加的装饰器函数
每个装饰器是一个高阶函数：输入 Handler，输出增强后的 Handler。例如日志、超时、重试：
立即学习“go语言免费学习笔记（深入）”；
-
日志装饰器：
func WithLogging(next Handler) Handler { ... } -
超时装饰器：
func WithTimeout(d time.Duration) func(Handler) Handler { ... }（支持传参） -
重试装饰器：
func WithRetry(attempts int, backoff time.Duration) func(Handler) Handler { ... }
注意：带参数的装饰器返回的是“装饰器构造器”，使用时需先调用再传入 next，比如 WithTimeout(5 * time.Second)(next)。
链式组装与调用
利用 Go 的函数调用顺序，从右到左包裹（类似 Unix 管道）：
raw := func(ctx context.Context, req interface{}) (interface{}, error) {
return "result", nil
}
<p>handler := WithLogging(
WithTimeout(3*time.Second)(
WithRetry(3, time.Second)(
raw,
),
),
)</p><p>result, err := handler(context.Background(), "req")执行时，请求会依次经过：重试 → 超时 → 日志 → 原始逻辑（反向嵌套）。你也可以封装一个 Chain 工具函数，让写法更线性：
func Chain(h Handler, middlewares ...func(Handler) Handler) Handler {
for i := len(middlewares) - 1; i >= 0; i-- {
h = middlewares[i](h)
}
return h
}
// 使用：
handler := Chain(raw, WithLogging, WithTimeout(3*time.Second), WithRetry(3, time.Second))进阶：支持上下文传递与泛型（Go 1.18+）
为避免 interface{} 的类型丢失，可用泛型提升类型安全：
type Handler[T, R any] func(context.Context, T) (R, error)
<p>func WithRecovery[T, R any](next Handler[T, R]) Handler[T, R] {
return func(ctx context.Context, req T) (R, error) {
defer func() {
if r := recover(); r != nil {
// 处理 panic
}
}()
return next(ctx, req)
}
}这样，输入/输出类型在编译期就确定，无需运行时断言，更健壮也更易读。
基本上就这些。Go 的装饰器链不是语法糖，而是基于组合与高阶函数的显式设计，清晰、可控、无魔法。关键在于统一接口、纯函数封装、以及合理的链式顺序。不复杂但容易忽略的是：每个装饰器应只做一件事，并保持错误透传，避免吞掉上游错误。
