编程模式之Go如何实现装饰器

[[410713]]

本文转载自微信公众号「Golang梦工厂」，作者AsongGo。转载本文请联系Golang梦工厂公众号。

前言

哈喽，大家好，我是asong。今天想与大家聊一聊如何用Go实现装饰器代码。为什么会有这个想法呢?最近由于项目需要一直在看python的代码，在这个项目中应用了大量的装饰器代码，一个装饰器代码可以在全文共用，减少了冗余代码。python的语法糖让实现装饰器变得很简单，但是Go语言的糖不多，而且又是强类型的静态无虚拟机的语言，所以，没有办法做到像Java 和 Python 那样写出优雅的装饰器的代码，但也是可以实现的，今天我们就看看如何Go语言写出装饰器代码!

什么是装饰器

介绍装饰器基本概念之前，我们先举个例子，跟装饰器很贴切：

如今我们的生活水平提高了，基本人手一台手机，大家也知道手机屏幕摔到地板上是很容易碎屏的，手机屏幕一坏，又要多花一笔费用进行维修，很是心痛;那么有什么什么办法来避免这个问题呢，在不破坏手机屏幕结构的情况下，让我们的手机更耐坏呢?其实我们只需要花几元钱买一个钢化膜，钢化膜在不改变原有手机屏幕的结构下，让手机变得更耐摔了。

根据上面这个例子，就可以引出本文的核心 -> 装饰器。装饰器本质就是：

函数装饰器用于在源码中“标记”函数，以某种方式增强函数的行为。

装饰器是一个强大的功能，但是若想掌握，必须要理解闭包!闭包的概念我们在下面一小节说明，我们先来看一看python是如何使用装饰器的：

 
 
 
    
  
  
  
  1. def metric(fn): 
    2. 
  
  
  
  2.     @functools.wraps(fn) 
    3. 
  
  
  
  3.     def timer(*arag, **kw): 
    4. 
  
  
  
  4.         start = time.time() 
    5. 
  
  
  
  5.         num = fn(*arag, **kw) 
    6. 
  
  
  
  6.         end = time.time() 
    7. 
  
  
  
  7.         times = (end - start) * 1000 
    8. 
  
  
  
  8.         print('%s executed in %s ms' % (fn.__name__, times)) 
    9. 
  
  
  
  9.         return num 
    10. 
  
  
  
  10.     return timer 
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12. @metric 
    13. 
  
  
  
  13. def Sum(x, y): 
    14. 
  
  
  
  14.     time.sleep(0.0012) 
    15. 
  
  
  
  15.     return x + y; 
    16. 
  
  
  
  16.  
    17. 
  
  
  
  17.  
    18. 
  
  
  
  18. Sum(10, 20) 
    19.

这里要实现功能很简单，metric就是一个装饰器函数，他可以作用于任何函数之上，并打印该函数的执行时间，有个这个装饰器，我们想要知道任何一个函数的执行时间，就简便很多了。

简单总结一下装饰器使用场景：

  • 插入日志：使面向切面编程变的更简单了。
  • 缓存：读写缓存使用装饰器来实现，减少了冗余代码。
  • 事务处理：使代码看起来更简洁了。
  • 权限校验：权限校验器是都是一套代码，减少了冗余代码。

装饰器的使用场景还用很多，就不一一列举了，下面我们就来看看如何使用Go也来实现装饰器代码吧!

闭包

装饰器的实现和闭包是分不开的，所以我们先来学习一下什么是闭包!

我们通常会把闭包和匿名函数弄混，这是因为：在 函数内部定义函数不常见，直到开始使用匿名函数才会这样做。而且， 只有涉及嵌套函数时才有闭包问题。因此，很多人是同时知道这两个概念的。

其实，闭包指延伸了作用域的函数，其中包含函数定义体中引用、但是不在定义体中定义的非全局变量。函数是不是匿名的没有关系，关键是 它能访问定义体之外定义的非全局变量。

光看概念其实挺难理解闭包，我们通过例子来进行理解。

 
 
 
    
  
  
  
  1. func makeAverager() func(val float32) float32{ 
    2. 
  
  
  
  2.  series := make([]float32,0) 
    3. 
  
  
  
  3.  return func(val float32) float32 { 
    4. 
  
  
  
  4.   series = append(series, val) 
    5. 
  
  
  
  5.   total := float32(0) 
    6. 
  
  
  
  6.   for _,v:=range series{ 
    7. 
  
  
  
  7.    total +=v 
    8. 
  
  
  
  8.   } 
    9. 
  
  
  
  9.   return total/ float32(len(series)) 
    10. 
  
  
  
  10.  } 
    11. 
  
  
  
  11. } 
    12. 
  
  
  
  12.  
    13. 
  
  
  
  13. func main() { 
    14. 
  
  
  
  14.  avg := makeAverager() 
    15. 
  
  
  
  15.  fmt.Println(avg(10)) 
    16. 
  
  
  
  16.  fmt.Println(avg(30)) 
    17. 
  
  
  
  17. } 
    18.

这个例子，你猜运行结果是什么?10,30还是10,20?

运行一下，答案出来了：10,20。为什么会这样呢?我们来分析一下!

上面的代码中makeAverager的写法在C语言中是不允许的，因为在C语言中，函数内的内存分配是在栈上的，在makeAverager返回后，这部分栈就被回收了，但是在Go语言中是没有问题的，因为Go语言会进行escape analyze分析出变量的作用范围，将变量在堆上进行内存分配，我们使用go build --gcflags=-m ./test/test1.go来看一下分析结果：

 
 
 
    
  
  
  
  1. # command-line-arguments 
    2. 
  
  
  
  2. test/test1.go:21:13: inlining call to fmt.Println 
    3. 
  
  
  
  3. test/test1.go:22:13: inlining call to fmt.Println 
    4. 
  
  
  
  4. test/test1.go:8:2: moved to heap: series 
    5. 
  
  
  
  5. test/test1.go:8:16: make([]float32, 0) escapes to heap 
    6. 
  
  
  
  6. test/test1.go:9:9: func literal escapes to heap 
    7. 
  
  
  
  7. test/test1.go:21:17: avg(10) escapes to heap 
    8. 
  
  
  
  8. test/test1.go:21:13: []interface {} literal does not escape 
    9. 
  
  
  
  9. test/test1.go:22:17: avg(30) escapes to heap 
    10. 
  
  
  
  10. test/test1.go:22:13: []interface {} literal does not escape 
    11. 
  
  
  
  11. :1: .this does not escape 
    12.

从运行结果我们可以看出，series、func、avg都逃逸到了堆上。所以我们可以得出结论，series变量和func(val float32) float32{}被引用后，他所在的函数结束，也不会马上销毁，这也是变相延长了函数的生命周期!

小结：综上所诉，闭包是一种函数，它会保留定义函数时存在的自由变量的绑定， 这样调用函数时，虽然定义作用域不可用了，但是仍能使用那些绑定。

注意，只有嵌套在其他函数中的函数才可能需要处理不在全局作用域中 的外部变量。

Gin中装饰器的应用

大家应该都使用过Gin这个Web框架，其在注册路由时提供了中间件的使用，可以拦截http请求-响应生命周期的特殊函数，在请求-响应生命周期中可以注册多个中间件，每个中间件执行不同的功能，一个中间执行完再轮到下一个中间件执行。这个中间件其实就是使用的装饰器，我们来看一件简单的例子：

 
 
 
    
  
  
  
  1. func VerifyHeader() gin.HandlerFunc { 
    2. 
  
  
  
  2.  return func(c *gin.Context) { 
    3. 
  
  
  
  3.   header := c.Request.Header.Get("token") 
    4. 
  
  
  
  4.   if header == "" { 
    5. 
  
  
  
  5.    c.JSON(200, gin.H{ 
    6. 
  
  
  
  6.     "code":   1000, 
    7. 
  
  
  
  7.     "msg":    "Not logged in", 
    8. 
  
  
  
  8.    }) 
    9. 
  
  
  
  9.    return 
    10. 
  
  
  
  10.   } 
    11. 
  
  
  
  11.  } 
    12. 
  
  
  
  12. } 
    13. 
  
  
  
  13. func main()  { 
    14. 
  
  
  
  14.  r := gin.Default() 
    15. 
  
  
  
  15.  group := r.Group("/api/asong",VerifyHeader()) 
    16. 
  
  
  
  16.  { 
    17. 
  
  
  
  17.   group.GET("/ping", func(context *gin.Context) { 
    18. 
  
  
  
  18.    context.JSON(200,gin.H{ 
    19. 
  
  
  
  19.     "message": "pong", 
    20. 
  
  
  
  20.    }) 
    21. 
  
  
  
  21.   }) 
    22. 
  
  
  
  22.  } 
    23. 
  
  
  
  23.  r.Run() 
    24. 
  
  
  
  24. } 
    25.

这段代码很简单，我们只需要写一个VerifyHeader函数，在注册路由的时候添加进去就可以了，当有请求进来时，会先执行gin.HanderFunc函数，在Gin框架中使用一个切片来存储的，所以在添加中间件时，要注意添加顺序哦!

 
 
 
    
  
  
  
  1. // HandlerFunc defines the handler used by gin middleware as return value. 
    2. 
  
  
  
  2. type HandlerFunc func(*Context) 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4. // HandlersChain defines a HandlerFunc array. 
    5. 
  
  
  
  5. type HandlersChain []HandlerFunc 
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7. func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain { 
    8. 
  
  
  
  8.  finalSize := len(group.Handlers) + len(handlers) 
    9. 
  
  
  
  9.  if finalSize >= int(abortIndex) { 
    10. 
  
  
  
  10.   panic("too many handlers") 
    11. 
  
  
  
  11.  } 
    12. 
  
  
  
  12.  mergedHandlers := make(HandlersChain, finalSize) 
    13. 
  
  
  
  13.  copy(mergedHandlers, group.Handlers) 
    14. 
  
  
  
  14.  copy(mergedHandlers[len(group.Handlers):], handlers) 
    15. 
  
  
  
  15.  return mergedHandlers 
    16. 
  
  
  
  16. } 
    17.

net/http使用装饰器

上面我们看到了装饰器在Gin框架中的应用，这种设计大大减少了冗余代码的出现，也使代码的可扩展性提高了。那么接下来我们就在标准库http包上自己实现一个装饰器，练习一下。

我们知道Go语言的http标准库是不能使用中间件的，所以我们的机会来了，我们来给他实现一个!看代码：

 
 
 
    
  
  
  
  1. type DecoratorHandler func(http.HandlerFunc) http.HandlerFunc 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. func MiddlewareHandlerFunc(hp http.HandlerFunc, decors ...DecoratorHandler) http.HandlerFunc { 
    4. 
  
  
  
  4.  for d := range decors { 
    5. 
  
  
  
  5.   dp := decors[len(decors)-1-d] 
    6. 
  
  
  
  6.   hp = dp(hp) 
    7. 
  
  
  
  7.  } 
    8. 
  
  
  
  8.  return hp 
    9. 
  
  
  
  9. } 
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11. func VerifyHeader(h http.HandlerFunc) http.HandlerFunc { 
    12. 
  
  
  
  12.  return func(w http.ResponseWriter, r *http.Request) { 
    13. 
  
  
  
  13.   token := r.Header.Get("token") 
    14. 
  
  
  
  14.   if token == "" { 
    15. 
  
  
  
  15.    fmt.Fprintf(w,r.URL.Path +" response: Not Logged in") 
    16. 
  
  
  
  16.    return 
    17. 
  
  
  
  17.   } 
    18. 
  
  
  
  18.   h(w,r) 
    19. 
  
  
  
  19.  } 
    20. 
  
  
  
  20. } 
    21. 
  
  
  
  21.  
    22. 
  
  
  
  22. func Pong(w http.ResponseWriter, r *http.Request)  { 
    23. 
  
  
  
  23.  fmt.Fprintf(w,r.URL.Path +"response: pong") 
    24. 
  
  
  
  24.  return 
    25. 
  
  
  
  25. } 
    26. 
  
  
  
  26.  
    27. 
  
  
  
  27.  
    28. 
  
  
  
  28. func main()  { 
    29. 
  
  
  
  29.  http.HandleFunc("/api/asong/ping",MiddlewareHandlerFunc(Pong,VerifyHeader)) 
    30. 
  
  
  
  30.  err := http.ListenAndServe(":8080", nil) 
    31. 
  
  
  
  31.  if err != nil { 
    32. 
  
  
  
  32.   log.Fatal("ListenAndServe: ", err) 
    33. 
  
  
  
  33.  } 
    34. 
  
  
  
  34. } 
    35.

实现起来还是比较简单，这里重新声明了DecoratorHandler类型，本质就是func(http.HandlerFunc) http.HandlerFunc，这样更加方便我们添加中间件函数，中间件按照添加的顺序执行。

总结

好啦，本文到这里就结束了，这一文我们学习了闭包的概念，通过闭包我们学习了如何在Go语言中使用装饰器，因为Go语言中不支持注解这个语法糖，所以使用装饰器还是有点丑陋的，不过这个思想还是挺重要的，我们日常开发中可以参考这种思想，写出更优质的代码来!

新闻标题：编程模式之Go如何实现装饰器
当前地址：http://www.shufengxianlan.com/qtweb/news23/323123.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

Google知识

分类信息网站

恒温恒湿空调机组　　 　谷歌优化排名　　 　成都手机网站开发　　 　成都网站建设　　 　网站建设方案　　 　网站快速收录　　 　网络营销推广　　 　成都免费网站建设　　 　虚拟主机　　 　红光高低压开关厂　　 　云主机　　 　成都主机托管　　 　关键词优化　　 　成都网站建设　　 　成都网站建设公司　　 　成都铺面装修　　 　企业手机网站建设　　 　达州网站制作　　 　成都电信光华数据中心　　 　营销型网站建设