修饰器

简单示例
HTTP
多个修饰器的 Pipeline
泛型的修饰器

修饰器模式很容易的可以把一些函数装配到另外一些函数上，可以让代码更为的简单

也可以让一些“小功能型”的代码复用性更高，让代码中的函数可以像乐高玩具那样自由地拼装

Go语言的修饰器编程模式，其实也就是函数式编程的模式

不过，要提醒注意的是，Go 语言的“糖”不多，而且又是强类型的静态无虚拟机的语言，所以，无法做到像 Java 和 Python 那样的优雅的修饰器的代码

简单示例

先来看一个示例：

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 语法糖。所以，在调用上有些难看

当然，如果要想让代码容易读一些，可以这样：

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

再来看一个和计算运行时间的例子：

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

关于上面的代码，有几个事说明一下：

有两个 Sum 函数
- Sum1() 函数就是简单的做个循环
- Sum2() 函数动用了数据公式。（注意：start 和 end 有可能有负数的情况）
代码中使用了 Go 语言的反射机器来获取函数名
修饰器函数是 timedSumFunc()

运行后输出：

$ go run calc-time.go 
--- Time Elapsed (main.Sum1): 2.790099ms ---
--- Time Elapsed (main.Sum2): 231ns ---
49999954995000, 49999954995000

HTTP

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

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() 就可以加入一个 Response 的 Header。

WithServerHeader() 函数就是一个 Decorator，其传入一个 http.HandlerFunc，然后返回一个改写的版本

这样的函数还可以写出好些个。如下所示，有写 HTTP 响应头的，有写认证 Cookie 的，有检查认证Cookie的，有打日志的：

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：

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
}

然后，就可以像下面这样使用了：

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

泛型的修饰器

对于 Go 的修饰器模式，还有一个小问题：好像无法做到泛型，就像上面那个计算时间的函数一样

其代码耦合了需要被修饰的函数的接口类型，无法做到非常通用

可以用 reflection 机制写的一个比较通用的修饰器（为了便于阅读，删除了出错判断代码）

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
}

这个 Decorator() 需要两个参数，
- 出参 decoPtr ，就是完成修饰后的函数
- 入参 fn ，就是需要修饰的函数
用 reflect.MakeFunc() 函数制出了一个新的函数 targetFunc.Call(in) : 这个新的函数会调用被修饰的函数

来看一下使用效果。假设有两个需要修饰的函数：

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
}

现在可以这么做：

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

使用 Decorator() 时，还需要先声明一个函数签名，感觉好傻啊。一点都不泛型，不是吗？

Next：管道

Previous：代码生成

Home：目录

修饰器

Table of Contents

简单示例

HTTP

多个修饰器的 Pipeline

泛型的修饰器