关于golang:编程模式之Go语言如何实现装饰器

52次阅读

共计 4915 个字符,预计需要花费 13 分钟才能阅读完成。

原文链接:编程模式之 Go 如何实现装璜器

前言

哈喽,大家好,我是 asong。明天想与大家聊一聊如何用Go 实现装璜器代码。为什么会有这个想法呢?最近因为我的项目须要始终在看 python 的代码,在这个我的项目中利用了大量的装璜器代码,一个装璜器代码能够在全文共用,缩小了冗余代码。python的语法糖让实现装璜器变得很简略,然而 Go 语言的 不多,而且又是强类型的动态无虚拟机的语言,所以,没有方法做到像 JavaPython 那样写出优雅的装璜器的代码,但也是能够实现的,明天咱们就看看如何Go 语言写出装璜器代码!

什么是装璜器

介绍装璜器基本概念之前,咱们先举个例子,跟装璜器很贴切:

现在咱们的生存程度进步了,根本人手一台手机,大家也晓得手机屏幕摔到地板上是很容易碎屏的,手机屏幕一坏,又要多花一笔费用进行培修,很是心痛;那么有什么什么方法来防止这个问题呢,在不毁坏手机屏幕构造的状况下,让咱们的手机更耐坏呢?其实咱们只须要花几元钱买一个钢化膜,钢化膜在不扭转原有手机屏幕的构造下,让手机变得更耐摔了。

依据下面这个例子,就能够引出本文的外围 -> 装璜器。装璜器实质就是:

函数装璜器用于在源码中“标记”函数,以某种形式加强函数的行为。

装璜器是一个弱小的性能,然而若想把握,必须要了解闭包!闭包的概念咱们在上面一大节阐明,咱们先来看一看 python 是如何应用装璜器的:

def metric(fn):
    @functools.wraps(fn)
    def timer(*arag, **kw):
        start = time.time()
        num = fn(*arag, **kw)
        end = time.time()
        times = (end - start) * 1000
        print('%s executed in %s ms' % (fn.__name__, times))
        return num
    return timer

@metric
def Sum(x, y):
    time.sleep(0.0012)
    return x + y;


Sum(10, 20)

这里要实现性能很简略,metric就是一个装璜器函数,他能够作用于任何函数之上,并打印该函数的执行工夫,有个这个装璜器,咱们想要晓得任何一个函数的执行工夫,就简便很多了。

简略总结一下装璜器应用场景:

  • 插入日志:使面向切面编程变的更简略了。
  • 缓存:读写缓存应用装璜器来实现,缩小了冗余代码。
  • 事务处理:使代码看起来更简洁了。
  • 权限校验:权限校验器是都是一套代码,缩小了冗余代码。

装璜器的应用场景还用很多,就不一一列举了,上面咱们就来看看如何应用 Go 也来实现装璜器代码吧!

闭包

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

咱们通常会把闭包和匿名函数弄混,这是因为:在 函数外部定义函数不常见,直到开始应用匿名函数才会这样做。而且,只有波及嵌套函数时才有闭包问题。因而,很多人是同时晓得这两个概念的。

其实,闭包指延长了作用域的函数,其中蕴含函数定义体中援用、然而不在定义体中定义的非全局变量。函数是不是匿名的没有关系,要害是 它能拜访定义体之外定义的非全局变量。

光看概念其实挺难了解闭包,咱们通过例子来进行了解。

func makeAverager() func(val float32) float32{series := make([]float32,0)
    return func(val float32) float32 {series = append(series, val)
        total := float32(0)
        for _,v:=range series{total +=v}
        return total/ float32(len(series))
    }
}

func main() {avg := makeAverager()
    fmt.Println(avg(10))
    fmt.Println(avg(30))
}

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

运行一下,答案进去了:10,20。为什么会这样呢?咱们来剖析一下!

下面的代码中 makeAverager 的写法在 C 语言中是不容许的,因为在 C 语言中,函数内的内存调配是在栈上的,在 makeAverager 返回后,这部分栈就被回收了,然而在 Go 语言中是没有问题的,因为 Go 语言会进行 escape analyze 剖析出变量的作用范畴,将变量在堆上进行内存调配,咱们应用 go build --gcflags=-m ./test/test1.go 来看一下剖析后果:

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

从运行后果咱们能够看出,seriesfuncavg都逃逸到了堆上。所以咱们能够得出结论,series变量和 func(val float32) float32{} 被援用后,他所在的函数完结,也不会马上销毁,这也是变相缩短了函数的生命周期!

小结:综上所诉,闭包是一种函数,它会保留定义函数时存在的自在变量的绑定,这样调用函数时,尽管定义作用域不可用了,然而仍能应用那些绑定。

留神,只有嵌套在其余函数中的函数才可能须要解决不在全局作用域中 的内部变量。

Gin 中装璜器的利用

大家应该都应用过 Gin 这个 Web 框架,其在注册路由时提供了中间件的应用,能够拦挡 http 申请 - 响应 生命周期的非凡函数,在申请 - 响应生命周期中能够注册多个中间件,每个中间件执行不同的性能,一个两头执行完再轮到下一个中间件执行。这个中间件其实就是应用的装璜器,咱们来看一件简略的例子:

func VerifyHeader() gin.HandlerFunc {return func(c *gin.Context) {header := c.Request.Header.Get("token")
        if header == "" {
            c.JSON(200, gin.H{
                "code":   1000,
                "msg":    "Not logged in",
            })
            return
        }
    }
}
func main()  {r := gin.Default()
    group := r.Group("/api/asong",VerifyHeader())
    {group.GET("/ping", func(context *gin.Context) {
            context.JSON(200,gin.H{"message": "pong",})
        })
    }
    r.Run()}

这段代码很简略,咱们只须要写一个 VerifyHeader 函数,在注册路由的时候增加进去就能够了,当有申请进来时,会先执行 gin.HanderFunc 函数,在 Gin 框架中应用一个切片来存储的,所以在增加中间件时,要留神增加程序哦!

// HandlerFunc defines the handler used by gin middleware as return value.
type HandlerFunc func(*Context)

// HandlersChain defines a HandlerFunc array.
type HandlersChain []HandlerFunc

func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain {finalSize := len(group.Handlers) + len(handlers)
    if finalSize >= int(abortIndex) {panic("too many handlers")
    }
    mergedHandlers := make(HandlersChain, finalSize)
    copy(mergedHandlers, group.Handlers)
    copy(mergedHandlers[len(group.Handlers):], handlers)
    return mergedHandlers
}

net/http 应用装璜器

下面咱们看到了装璜器在 Gin 框架中的利用,这种设计大大减少了冗余代码的呈现,也使代码的可扩展性进步了。那么接下来咱们就在规范库 http 包上本人实现一个装璜器,练习一下。

咱们晓得 Go 语言的 http 规范库是不能应用中间件的,所以咱们的机会来了,咱们来给他实现一个!看代码:

type DecoratorHandler func(http.HandlerFunc) http.HandlerFunc

func MiddlewareHandlerFunc(hp http.HandlerFunc, decors ...DecoratorHandler) http.HandlerFunc {
    for d := range decors {dp := decors[len(decors)-1-d]
        hp = dp(hp)
    }
    return hp
}

func VerifyHeader(h http.HandlerFunc) http.HandlerFunc {return func(w http.ResponseWriter, r *http.Request) {token := r.Header.Get("token")
        if token == "" {fmt.Fprintf(w,r.URL.Path +"response: Not Logged in")
            return
        }
        h(w,r)
    }
}

func Pong(w http.ResponseWriter, r *http.Request)  {fmt.Fprintf(w,r.URL.Path +"response: pong")
    return
}


func main()  {http.HandleFunc("/api/asong/ping",MiddlewareHandlerFunc(Pong,VerifyHeader))
    err := http.ListenAndServe(":8080", nil)
    if err != nil {log.Fatal("ListenAndServe:", err)
    }
}

实现起来还是比较简单,这里从新申明了 DecoratorHandler 类型,实质就是func(http.HandlerFunc) http.HandlerFunc,这样更加不便咱们增加中间件函数,中间件依照增加的程序执行。

总结

好啦,本文到这里就完结了,这一文咱们学习了闭包的概念,通过闭包咱们学习了如何在 Go 语言中应用装璜器,因为 Go 语言中不反对注解这个语法糖,所以应用装璜器还是有点俊俏的,不过这个思维还是挺重要的,咱们日常开发中能够参考这种思维,写出更优质的代码来!

素质三连(分享、点赞、在看)都是笔者继续创作更多优质内容的能源!我是asong,咱们下期见。

创立了一个 Golang 学习交换群,欢送各位大佬们踊跃入群,咱们一起学习交换。入群形式:关注公众号获取。更多学习材料请到公众号支付。

欢送关注公众号:Golang 梦工厂

举荐往期文章:

  • 学习 channel 设计:从入门到放弃
  • Go 语言如何实现可重入锁?
  • Go 语言中 new 和 make 你应用哪个来分配内存?
  • 源码分析 panic 与 recover,看不懂你打我好了!
  • 空构造体引发的大型打脸现场
  • 面试官:两个 nil 比拟后果是什么?
  • 面试官:你能用 Go 写段代码判断以后零碎的存储形式吗?
  • 面试中如果这样写二分查找

正文完
 0