读代码之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，就会一直递归往复（这是一个有退出条件的闭环），所以小伙伴们都绕明白了吗

如果用python实现起来其实就相对简单多了，这里就不再给出代码了。换个思路，为了加强理解，如果用python实现一个上面golang风格的代码呢？感兴趣可以实现一下，会更好的帮助你理解golang以及python的风格用法特点，这里给出参考：

class CacheFib(object):

    def __init__(self):
        self.cache = dict()
        self.f = None

    def wrap(self, obj):
        self.f = obj.fib
        # return self

    def fib(self, n):
        if not self.cache.get(n):
            self.cache[n] = self.f(n)

        return self.cache[n]


class CountFib(object):

    def __init__(self):
        self.count = 0
        self.f = None

    def wrap(self, obj):
        self.f = obj.fib
        # return self

    def fib(self, n):
        self.count += 1
        return  self.f(n)


class Fib(object):

    def __init__(self):
        self.f = self.fib

    def wrap(self, obj):
        self.f = obj.fib
        # return self

    def fib(self, n)->int:
        if n == 0:
            return 0
        elif n == 1:
            return 1
        else:
            return self.f(n-1) + self.f(n-2)


if __name__ == '__main__':
    f = Fib()
    cache = CacheFib()
    count = CountFib()

    f.wrap(cache)
    count.wrap(f)
    cache.wrap(count)

    # cache = cache.wrap(count.wrap(f.wrap(cache))
    cache.fib(20)
    print("count: {}, cache: {}".format(count.count, cache.cache) )