读代码之golang装饰器模式

在 v站 看到一篇文章，说到了golang实现python装饰器的方法，有两个实现方式

其中一种是用类方式实现的，当时泛览了下代码，觉得 emmm…实现方式挺花哨的，貌似看懂了就没怎么在意，当时特意把代码复制到goland中作为参考了

某天上班摸鱼，仔细看了下这段代码，梳理细节后忽然发现没get到其中逻辑

郁闷很久未参透

有空就特意调试打印下这段代码

好几天才整明白，这大概就是菜比の理解能力了吧

代码如下：

// with interface. which we need create a `point` first. and use it later

package main

import "fmt"

type FibI interface {
    Fib(n int) int
    Wrap(fib FibI) FibI
}

type Fib struct {
    Wrapper FibI
}

func (this *Fib) Fib(n int) int {
    //wrapper := this.Wrapper
    if this.Wrapper == nil {
        this.Wrapper = this
    }
    fmt.Printf("我执行了...%T...%v\n", this.Wrapper, n)
    if n == 0 {
        return 0
    }
    if n == 1 {
        return 1
    }
    // call son
    fmt.Printf("leixing9...%T...\n", this.Wrapper)
    return this.Wrapper.Fib(n-1) + this.Wrapper.Fib(n-2)
}

func (this *Fib) Wrap(fib FibI) FibI {
    fmt.Printf("leixing1...%T...\n", this.Wrapper)
    this.Wrapper = fib
    fmt.Printf("leixing2...%T...\n", this.Wrapper)
    fmt.Println("fib 调用", this)
    return this
}

type CacheFib struct {
    Wrapper FibI
    cache   map[int]int
}

func (this *CacheFib) Wrap(fib FibI) FibI {
    this.Wrapper = fib
    fmt.Printf("leixing6...%T...\n", this.Wrapper)
    return this
}

func (this *CacheFib) Fib(n int) int {
    if this.cache == nil {
        this.cache = make(map[int]int)
    }
    if ans, ok := this.cache[n]; ok {
        return ans
    }
    ans := this.Wrapper.Fib(n)
    this.cache[n] = ans
    return ans
}

type CounterFib struct {
    Wrapper FibI
    Counter int
}

func (this *CounterFib) Wrap(fib FibI) FibI {
    this.Wrapper = fib
    fmt.Printf("leixing...%T...\n", this.Wrapper)
    return this
}

func (this *CounterFib) Fib(n int) int {
    this.Counter++
    return this.Wrapper.Fib(n)
}

func main() {
    fib := new(Fib)
    //fmt.Println("result fib", fib.Fib(10))

    cacheFib := new(CacheFib)
    //f := cacheFib.Wrap(fib.Wrap(cacheFib))
    //fmt.Println(f.Fib(10), "heihei")
    counterFib := new(CounterFib)
    counterCacheFib := cacheFib.Wrap(counterFib.Wrap(fib.Wrap(cacheFib)))
    fmt.Println("result cache:counter:fib", counterCacheFib.Fib(10))
    fmt.Printf("count: %d, cache: %v", counterFib.Counter, cacheFib.cache)
}

本文的目的没有那么高大上，就是简单的理解一下，这种装饰器实现及其后的核心原理

讲真，这个代码实现的挺花哨的>_<

所以，我把自己的那些调试打印信息也一并给出了

首先第一步：

背景：用装饰器的原理实现斐波那契数列的计算

如果有golang语法基础，相信这些main函数之前的代码应该理解起来不难

其中Fib结构是一个实现了FibI接口的对象

乍看之下好像仅此而已

CacheFib结构也同样实现了此接口，不过提供了一个map数据结构，会把之前计算过的数值缓存起来，后面调用直接取缓存

CounterFib结构就简单啦，它计算了CounterFib实例调用Fib方法的次数

三个Fib类的Wrap方法实现方式都一样：就是把自身的Wrapper属性赋值为参数中的（实现了）FibI值

一直到main函数之前，这些代码还都不难理解

最后注意下主函数内的调用方法

cacheFib.Wrap(counterFib.Wrap(fib.Wrap(cacheFib)))

瞬间懵逼有木有

乍看之下，为什么cacheFib会出现两次，看起来好像是自己引用了自己（递归也是自己调用自己，好好参悟一下）

嗯，那些能明白这行代码的童鞋可以先行告退了，没懂得同学咱门继续

不明白的话就运行一遍代码：

斐波那契数列计算完美，有计算次数，也优化了计算逻辑（缓存了）

但这并不妨碍咱们的懵逼状态ing~

整个方法的调用链是怎样的呢

我在各个位置加了打印信息，其核心就是Fib方法

通过打印可以发现，每次计算n数值的时候都会调用Fib 对象的Fib 方法（有点绕）

打印Fib 对象的Wrapper类型， 显示为main.CacheFib类型

所以，我们重新回顾下Fib对象，其实它没那么简单，首先 对象的Wrapper 属性本身类型就是实现了FibI 接口的类型，其次对象本身也实现FibI 接口

Fib 对象的Fib 方法中调用了 Fib 对象的Wrapper属性的Fib方法（还是很绕，注意区分下Fib对象和Fib方法，这是两个概念）

那么回头来看main函数中的实现，cacheFib 是CacheFib类的实例，cacheFib使用Wrap方法用counterFib对象来装饰自身，但是counterFib对象的Wrapper被fib对象装饰了，同时fib对象又被cacheFib自身装饰了，那么当我们执行 counterCacheFib.Fib(10) 是时候，经过层层装饰，其实调用的方法是fib对象的Fib方法，fib对象的Fib方法在每次执行的时候又会调用自身Wrapper的Fib方法（不过这是一个类似递归的操作，只有当参数n大于1的时候才会调用自身的Wrapper的Fib方法）,不过Fib.Wrapper又被cacheFib装饰了，所以绕了一圈又回来了，只要入参n大于1，就会一直递归往复（这是一个有退出条件的闭环）， 所以小伙伴们都绕明白了吗