如何使用Golang实现装饰器模式_使用Decorator Pattern增强功能_技术教程

Go语言虽无类继承和装饰器语法糖，但可通过函数类型、高阶函数与接口实现装饰器模式：定义HandlerFunc类型，编写WithLogging、WithRetry等装饰器函数，支持链式组合与context增强，以轻量、非侵入方式添加横切逻辑。

Go 语言没有类和继承，也不支持像 Python 那样用 @decorator 语法糖，但完全可以用函数式组合 + 接口 + 高阶函数的方式优雅实现装饰器模式的核心思想：在不修改原始逻辑的前提下，动态地添加横切行为（如日志、重试、熔断、认证等）。

用函数类型定义“可装饰的服务”

装饰器本质是“包装函数”，所以先定义统一的服务接口。推荐使用函数类型而非接口，更轻量且符合 Go 的惯用法：

// 定义核心业务行为：处理请求并返回响应
type HandlerFunc func(req interface{}) (resp interface{}, err error)
// 基础实现示例
func SimpleHandler(req interface{}) (interface{}, error) {
return "OK", nil
}

编写通用装饰器函数

每个装饰器接收一个 HandlerFunc，返回一个新的 HandlerFunc，内部调用原函数前后插入逻辑：

日志装饰器：打印入参和耗时

func WithLogging(next HandlerFunc) HandlerFunc {
    return func(req interface{}) (interface{}, error) {
        log.Printf("→ Start handling: %+v", req)
        start := time.Now()
        resp, err := next(req)
        log.Printf("← Done in %v, result: %+v, err: %v", 
            time.Since(start), resp, err)
        return resp, err
    }
}

重试装饰器：失败时自动重试 3 次

func WithRetry(maxRetries int) func(HandlerFunc) HandlerFunc {
    return func(next HandlerFunc) HandlerFunc {
        return func(req interface{}) (interface{}, error) {
            var lastErr error
            for i := 0; i <= maxRetries; i++ {
                if i > 0 {
                    time.Sleep(time.Second * time.Duration(i)) // 指数退避
                }
                if resp, err := next(req); err == nil {
                    return resp, nil
                } else {
                    lastErr = err
                }
            }
            return nil, lastErr
        }
    }
}

链式组合多个装饰器

利用高阶函数特性，按需叠加，顺序决定执行顺序（从外到内）：

// 组装：先重试 → 再日志 → 最终执行业务
handler := WithRetry(2)(WithLogging(SimpleHandler))
// 调用
result, err := handler("test-request")
// 输出类似：
// → Start handling: test-request
// ← Done in 123µs, result: OK, err:

也可以封装成更清晰的链式写法（非必须，但可读性更好）：

func Chain(handlers ...func(HandlerFunc) HandlerFunc) func(HandlerFunc) HandlerFunc {
    return func(final HandlerFunc) HandlerFunc {
        for i := len(handlers) - 1; i >= 0; i-- {
            final = handlers[i](final)
        }
        return final
    }
}
// 使用
handler := Chain(WithRetry(2), WithLogging)(SimpleHandler)

进阶：支持上下文与错误分类

生产环境建议增强装饰器对 context.Context 和结构化错误的支持：

把 HandlerFunc 升级为 func(ctx context.Context, req interface{}) (interface{}, error)
装饰器内部检查 ctx.Err() 提前退出
用自定义错误类型（如 ErrTimeout, ErrUnauthorized）区分处理，避免装饰器盲目重试认证失败

例如熔断装饰器可基于错误类型+失败率动态开启/关闭，而不仅依赖 error != nil。

基本上就这些。Go 的装饰器不是语法特性，而是设计习惯——用小函数、组合优先、不侵入业务逻辑。只要接口定义得当，加个日志或超时控制，一行代码就能完成。