GO语言的修饰器编程

本文介绍了Go语言中修饰器的实现方式,通过函数式编程思想,展示了如何创建和使用修饰器,包括简单示例、HTTP请求处理、多个修饰器的Pipeline以及泛型修饰器的探讨。文章还讨论了Go语言在实现修饰器时与Python和Java的差异,并提供了实际代码示例。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

之前写过一篇《Python修饰器的函数式编程》,这种模式很容易的可以把一些函数装配到另外一些函数上,可以让你的代码更为的简单,也可以让一些“小功能型”的代码复用性更高,让代码中的函数可以像乐高玩具那样自由地拼装。所以,一直以来,我对修饰器decoration这种编程模式情有独钟,这里写一篇Go语言相关的文章。

看过Python修饰器那篇文章的同学,一定知道这是一种函数式编程的玩法——用一个高阶函数来包装一下。多唠叨一句,关于函数式编程,可以参看我之前写过一篇文章《函数式编程》,这篇文章主要是,想通过从过程式编程的思维方式过渡到函数式编程的思维方式,从而带动更多的人玩函数式编程,所以,如果你想了解一下函数式编程,那么可以移步先阅读一下。所以,Go语言的修饰器编程模式,其实也就是函数式编程的模式。

不过,要提醒注意的是,Go 语言的“糖”不多,而且又是强类型的静态无虚拟机的语言,所以,无法做到像 Java 和 Python 那样的优雅的修饰器的代码。当然,也许是我才才疏学浅,如果你知道有更多的写法,请你一定告诉我。先谢过了。

简单示例

我们先来看一个示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main
 
import "fmt"
 
func decorator(f func(s string)) func(s string) {
 
         return func(s string) {
                 fmt.Println( "Started" )
                 f(s)
                 fmt.Println( "Done" )
         }
}
 
func Hello(s string) {
         fmt.Println(s)
}
 
func main() {
         decorator(Hello)( "Hello, World!" )
}

我们可以看到,我们动用了一个高阶函数 decorator(),在调用的时候,先把 Hello()函数传进去,然后其返回一个匿名函数,这个匿名函数中除了运行了自己的代码,也调用了被传入的 Hello() 函数。

这个玩法和 Python 的异曲同工,只不过,有些遗憾的是,Go 并不支持像 Python 那样的@decorator 语法糖。所以,在调用上有些难看。当然,如果你要想让代码容易读一些,你可以这样:

1
2
hello := decorator(Hello)
hello( "Hello" )

我们再来看一个和计算运行时间的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package main
 
import (
   "fmt"
   "reflect"
   "runtime"
   "time"
)
 
type SumFunc func(int64, int64) int64
 
func getFunctionName(i interface{}) string {
   return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
}
 
func timedSumFunc(f SumFunc) SumFunc {
   return func(start, end int64) int64 {
 
     defer func(t time .Time) {
       fmt.Printf( "--- Time Elapsed (%s): %v ---\n" ,
           getFunctionName(f), time .Since(t))
     }( time .Now())
 
     return f(start, end)
   }
}
 
func Sum1(start, end int64) int64 {
   var sum int64
   sum = 0
   if start > end {
     start, end = end, start
   }
   for i := start; i <= end; i++ {
     sum += i
   }
   return sum
}
 
func Sum2(start, end int64) int64 {
   if start > end {
     start, end = end, start
   }
   return (end - start + 1) * (end + start) / 2
}
 
func main() {
 
   sum1 := timedSumFunc(Sum1)
   sum2 := timedSumFunc(Sum2)
 
   fmt.Printf( "%d, %d\n" , sum1(-10000, 10000000), sum2(-10000, 10000000))
}

关于上面的代码,有几个事说明一下:


文末福利


1.赠送技术图书,面试真题,共计50G干货资源。

获取方式:关注本公众号,回复“干货”。


2.免费微信交流群:包括健身群,运动群,交友群,学习群,求职群,讨论群,老乡群,学生群,校招群,跑步群,聚餐群

入群方式:关注本公众号,回复“入群



1)有两个 Sum 函数,Sum1() 函数就是简单的做个循环,Sum2() 函数动用了数据公式。(注意:start 和 end 有可能有负数的情况)

2)代码中使用了 Go 语言的反射机器来获取函数名。

3)修饰器函数是 timedSumFunc()

运行后输出:

1
2
3
4
$ go run time . sum .go
--- Time Elapsed (main.Sum1): 3.557469ms ---
--- Time Elapsed (main.Sum2): 291ns ---
49999954995000, 49999954995000
HTTP 相关的一个示例

我们再来看一个处理 HTTP 请求的相关的例子。

先看一个简单的 HTTP Server 的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package main
 
import (
         "fmt"
         "log"
         "net/http"
         "strings"
)
 
func WithServerHeader(h http.HandlerFunc) http.HandlerFunc {
         return func(w http.ResponseWriter, r *http.Request) {
                 log .Println( "--->WithServerHeader()" )
                 w.Header().Set( "Server" , "HelloServer v0.0.1" )
                 h(w, r)
         }
}
 
func hello(w http.ResponseWriter, r *http.Request) {
         log .Printf( "Recieved Request %s from %s\n" , r.URL.Path, r.RemoteAddr)
         fmt.Fprintf(w, "Hello, World! " +r.URL.Path)
}
 
func main() {
         http.HandleFunc( "/v1/hello" , WithServerHeader(hello))
         err := http.ListenAndServe( ":8080" , nil)
         if err != nil {
                 log .Fatal( "ListenAndServe: " , err)
         }
}

上面代码中使用到了修饰模式,WithServerHeader() 函数就是一个 Decorator,其传入一个 http.HandlerFunc,然后返回一个改写的版本。上面的例子还是比较简单,用WithServerHeader() 就可以加入一个 Response 的 Header。

于是,这样的函数我们可以写出好些个。如下所示,有写 HTTP 响应头的,有写认证 Cookie 的,有检查认证Cookie的,有打日志的……

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package main
 
import (
         "fmt"
         "log"
         "net/http"
         "strings"
)
 
func WithServerHeader(h http.HandlerFunc) http.HandlerFunc {
         return func(w http.ResponseWriter, r *http.Request) {
                 log .Println( "--->WithServerHeader()" )
                 w.Header().Set( "Server" , "HelloServer v0.0.1" )
                 h(w, r)
         }
}
 
func WithAuthCookie(h http.HandlerFunc) http.HandlerFunc {
         return func(w http.ResponseWriter, r *http.Request) {
                 log .Println( "--->WithAuthCookie()" )
                 cookie := &http.Cookie{Name: "Auth" , Value: "Pass" , Path: "/" }
                 http.SetCookie(w, cookie)
                 h(w, r)
         }
}
 
func WithBasicAuth(h http.HandlerFunc) http.HandlerFunc {
         return func(w http.ResponseWriter, r *http.Request) {
                 log .Println( "--->WithBasicAuth()" )
                 cookie, err := r.Cookie( "Auth" )
                 if err != nil || cookie.Value != "Pass" {
                         w.WriteHeader(http.StatusForbidden)
                         return
                 }
                 h(w, r)
         }
}
 
func WithDebugLog(h http.HandlerFunc) http.HandlerFunc {
         return func(w http.ResponseWriter, r *http.Request) {
                 log .Println( "--->WithDebugLog" )
                 r.ParseForm()
                 log .Println(r.Form)
                 log .Println( "path" , r.URL.Path)
                 log .Println( "scheme" , r.URL.Scheme)
                 log .Println(r.Form[ "url_long" ])
                 for k, v := range r.Form {
                         log .Println( "key:" , k)
                         log .Println( "val:" , strings.Join(v, "" ))
                 }
                 h(w, r)
         }
}
func hello(w http.ResponseWriter, r *http.Request) {
         log .Printf( "Recieved Request %s from %s\n" , r.URL.Path, r.RemoteAddr)
         fmt.Fprintf(w, "Hello, World! " +r.URL.Path)
}
 
func main() {
         http.HandleFunc( "/v1/hello" , WithServerHeader(WithAuthCookie(hello)))
         http.HandleFunc( "/v2/hello" , WithServerHeader(WithBasicAuth(hello)))
         http.HandleFunc( "/v3/hello" , WithServerHeader(WithBasicAuth(WithDebugLog(hello))))
         err := http.ListenAndServe( ":8080" , nil)
         if err != nil {
                 log .Fatal( "ListenAndServe: " , err)
         }
}
多个修饰器的 Pipeline

在使用上,需要对函数一层层的套起来,看上去好像不是很好看,如果需要 decorator 比较多的话,代码会比较难看了。嗯,我们可以重构一下。

重构时,我们需要先写一个工具函数——用来遍历并调用各个 decorator:

1
2
3
4
5
6
7
8
9
type HttpHandlerDecorator func(http.HandlerFunc) http.HandlerFunc
 
func Handler(h http.HandlerFunc, decors ...HttpHandlerDecorator) http.HandlerFunc {
         for i := range decors {
                 d := decors[len(decors)-1-i] // iterate in reverse
                 h = d(h)
         }
         return h
}

然后,我们就可以像下面这样使用了。

1
2
http.HandleFunc( "/v4/hello" , Handler(hello,
                 WithServerHeader, WithBasicAuth, WithDebugLog))

这样的代码是不是更易读了一些?pipeline 的功能也就出来了。

泛型的修饰器

不过,对于 Go 的修饰器模式,还有一个小问题 —— 好像无法做到泛型,就像上面那个计算时间的函数一样,其代码耦合了需要被修饰的函数的接口类型,无法做到非常通用,如果这个事解决不了,那么,这个修饰器模式还是有点不好用的。

因为 Go 语言不像 Python 和 Java,Python是动态语言,而 Java 有语言虚拟机,所以他们可以干好些比较变态的事,然而 Go 语言是一个静态的语言,这意味着其类型需要在编译时就要搞定,否则无法编译。不过,Go 语言支持的最大的泛型是 interface{} 还有比较简单的 reflection 机制,在上面做做文章,应该还是可以搞定的。

废话不说,下面是我用 reflection 机制写的一个比较通用的修饰器(为了便于阅读,我删除了出错判断代码)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func Decorator(decoPtr, fn interface{}) (err error) {
         var decoratedFunc, targetFunc reflect.Value
 
         decoratedFunc = reflect.ValueOf(decoPtr).Elem()
         targetFunc = reflect.ValueOf(fn)
 
         v := reflect.MakeFunc(targetFunc.Type(),
                 func(in []reflect.Value) (out []reflect.Value) {
                         fmt.Println( "before" )
                         out = targetFunc.Call(in)
                         fmt.Println( "after" )
                         return
                 })
 
         decoratedFunc.Set(v)
         return
}

上面的代码动用了 reflect.MakeFunc() 函数制出了一个新的函数其中的targetFunc.Call(in) 调用了被修饰的函数。关于 Go 语言的反射机制,推荐官方文章 —— 《The Laws of Reflection》,在这里我不多说了。

上面这个 Decorator() 需要两个参数,

  • 第一个是出参 decoPtr ,就是完成修饰后的函数
  • 第二个是入参 fn ,就是需要修饰的函数

这样写是不是有些二?的确是的。不过,这是我个人在 Go 语言里所能写出来的最好的的代码了。如果你知道更多优雅的,请你一定告诉我!

好的,让我们来看一下使用效果。首先假设我们有两个需要修饰的函数:

1
2
3
4
5
6
7
8
9
func foo(a, b, c int ) int {
         fmt.Printf( "%d, %d, %d \n" , a, b, c)
         return a + b + c
}
 
func bar(a, b string) string {
         fmt.Printf( "%s, %s \n" , a, b)
         return a + b
}

然后,我们可以这样做:

1
2
3
4
type MyFoo func( int , int , int ) int
var myfoo MyFoo
Decorator(&myfoo, foo)
myfoo(1, 2, 3)

你会发现,使用 Decorator() 时,还需要先声明一个函数签名,感觉好傻啊。一点都不泛型,不是吗?

嗯。如果你不想声明函数签名,那么你也可以这样

1
2
3
mybar := bar
Decorator(&mybar, bar)
mybar( "hello," , "world!" )

好吧,看上去不是那么的漂亮,但是 it works。看样子 Go 语言目前本身的特性无法做成像 Java 或 Python 那样,对此,我们只能多求 Go 语言多放糖了!

Again, 如果你有更好的写法,请你一定要告诉我。


原文:https://coolshell.cn/articles/17929.html  作者:陈皓

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值