Go语言中装饰器的用法

装饰器（Decorator）是一种常见的编程模式，用于在不修改原始函数或方法的情况下扩展其功能。虽然Go语言没有像Python那样的原生装饰器语法，但通过高阶函数和闭包，我们仍然可以实现类似的装饰器模式。

基本概念

在Go中，装饰器本质上是一个函数，它接收一个函数作为参数，并返回一个新的函数。这个新函数通常会包装原始函数，在调用前后执行额外的逻辑。

type Decorator func(f func()) func()

func LogDecorator(f func()) func() {
    return func() {
        fmt.Println("Start executing function")
        f()
        fmt.Println("Finish executing function")
    }
}

常见应用场景

1. 日志记录

func Logger(f func(string)) func(string) {
    return func(s string) {
        start := time.Now()
        fmt.Printf("Calling function with param: %s\n", s)
        f(s)
        fmt.Printf("Function executed in %v\n", time.Since(start))
    }
}

func Greet(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

func main() {
    decoratedGreet := Logger(Greet)
    decoratedGreet("World")
}

2. 性能监控

func TimeIt(f func()) func() {
    return func() {
        start := time.Now()
        f()
        elapsed := time.Since(start)
        fmt.Printf("Function took %s\n", elapsed)
    }
}

func HeavyComputation() {
    time.Sleep(1 * time.Second)
}

func main() {
    timedHeavyComputation := TimeIt(HeavyComputation)
    timedHeavyComputation()
}

3. 错误处理

func ErrorHandler(f func() error) func() error {
    return func() error {
        err := f()
        if err != nil {
            fmt.Printf("Error occurred: %v\n", err)
        }
        return err
    }
}

func MightFail() error {
    if rand.Intn(2) == 0 {
        return errors.New("random error")
    }
    return nil
}

func main() {
    safeMightFail := ErrorHandler(MightFail)
    safeMightFail()
}

多参数装饰器

对于有多个参数的函数，我们可以使用可变参数或定义特定签名的装饰器：

func GenericLogger(f interface{}) interface{} {
    switch fn := f.(type) {
    case func(int):
        return func(n int) {
            fmt.Printf("Calling with int: %d\n", n)
            fn(n)
        }
    case func(string):
        return func(s string) {
            fmt.Printf("Calling with string: %s\n", s)
            fn(s)
        }
    default:
        panic("unsupported function type")
    }
}

装饰器链

我们可以将多个装饰器组合起来，形成装饰器链：

func Compose(decorators ...Decorator) Decorator {
    return func(f func()) func() {
        for i := len(decorators) - 1; i >= 0; i-- {
            f = decorators[i](f)
        }
        return f
    }
}

func main() {
    composed := Compose(TimeIt, LogDecorator)(HeavyComputation)
    composed()
}

结构体方法装饰器

装饰器也可以应用于结构体方法：

type Service struct{}

func (s *Service) Process() {
    fmt.Println("Processing...")
}

func MethodLogger(f func()) func() {
    return func() {
        fmt.Println("Before method call")
        f()
        fmt.Println("After method call")
    }
}

func main() {
    s := &Service{}
    decoratedProcess := MethodLogger(s.Process)
    decoratedProcess()
}

注意事项

1. Go的静态类型系统使得装饰器的实现不如动态语言灵活
2. 过度使用装饰器可能会降低代码可读性
3. 装饰器会增加函数调用栈的深度，可能影响性能
4. 对于需要修改参数或返回值的场景，需要更复杂的实现

总结

虽然Go没有内置的装饰器语法，但通过高阶函数和闭包，我们仍然可以实现强大的装饰器模式。装饰器在日志记录、性能监控、错误处理等横切关注点上特别有用。合理使用装饰器可以帮助我们保持代码的DRY原则，同时提高代码的可维护性。