在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) )