7.9 GO中间件(Middleware )

中间件是一种计算机软件，可为操作系统提供的软件应用程序提供服务，以便于各个软件之间的沟通，特别是系统软件和应用软件。广泛用于web应用和面向服务的体系结构等。

纵观GO语言，中间件应用比较普遍，主要应用：

  • 记录对服务器发送的请求（request）
  • 处理服务器响应（response ）
  • 请求和处理之间做一个权限认证工作
  • 远程调用
  • 安全
  • 等等

中间件处理程序是简单的http.Handler，它包装另一个http.Handler做请求的一些预处理和/或后处理。它被称为“中间件”，因为它位于Go Web服务器和实际处理程序之间的中间位置。

中间件(Middleware ) - 图1

下面是一些中间件例子

记录日志中间件

  1. package main
  3. import (
  4.    "fmt"
  5.    "log"
  6.    "net/http"
  7. )
  9. func logging(f http.HandlerFunc) http.HandlerFunc {
  10.    return func(w http.ResponseWriter, r *http.Request) {
  11.       log.Println(r.URL.Path)
  12.       f(w, r)
  13.    }
  14. }
  15. func foo(w http.ResponseWriter, r *http.Request) {
  16.    fmt.Fprintln(w, "foo")
  17. }
  19. func bar(w http.ResponseWriter, r *http.Request) {
  20.    fmt.Fprintln(w, "bar")
  21. }
  23. func main() {
  24.    http.HandleFunc("/foo", logging(foo))
  25.    http.HandleFunc("/bar", logging(bar))
  26.    http.ListenAndServe(":8080", nil)
  27. }

访问 http://localhost:8080/foo

返回结果

foo

将上面示例修改下，也可以实现相同的功能。

  1. package main
  3. import (
  4.    "fmt"
  5.    "log"
  6.    "net/http"
  7. )
  9. func foo(w http.ResponseWriter, r *http.Request) {
  10.    fmt.Fprintln(w, "foo")
  11. }
  12. func bar(w http.ResponseWriter, r *http.Request) {
  13.    fmt.Fprintln(w, "bar")
  14. }
  16. func loggingMiddleware(next http.Handler) http.Handler {
  17.    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  18.       log.Println(r.URL.Path)
  19.       next.ServeHTTP(w, r)
  20.    })
  21. }
  23. func main() {
  25.    http.Handle("/foo", loggingMiddleware(http.HandlerFunc(foo)))
  26.    http.Handle("/bar", loggingMiddleware(http.HandlerFunc(bar)))
  27.    http.ListenAndServe(":8080", nil)
  28. }

访问 http://localhost:8080/foo

返回结果

foo

多中间件例子

  1. package main
  3. import (
  4.    "fmt"
  5.    "log"
  6.    "net/http"
  7.    "time"
  8. )
  10. type Middleware func(http.HandlerFunc) http.HandlerFunc
  12. // Logging logs all requests with its path and the time it took to process
  13. func Logging() Middleware {
  15.    // Create a new Middleware
  16.    return func(f http.HandlerFunc) http.HandlerFunc {
  18.       // Define the http.HandlerFunc
  19.       return func(w http.ResponseWriter, r *http.Request) {
  21.          // Do middleware things
  22.          start := time.Now()
  23.          defer func() { log.Println(r.URL.Path, time.Since(start)) }()
  25.          // Call the next middleware/handler in chain
  26.          f(w, r)
  27.       }
  28.    }
  29. }
  31. // Method ensures that url can only be requested with a specific method, else returns a 400 Bad Request
  32. func Method(m string) Middleware {
  34.    // Create a new Middleware
  35.    return func(f http.HandlerFunc) http.HandlerFunc {
  37.       // Define the http.HandlerFunc
  38.       return func(w http.ResponseWriter, r *http.Request) {
  40.          // Do middleware things
  41.          if r.Method != m {
  42.             http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
  43.             return
  44.          }
  46.          // Call the next middleware/handler in chain
  47.          f(w, r)
  48.       }
  49.    }
  50. }
  52. // Chain applies middlewares to a http.HandlerFunc
  53. func Chain(f http.HandlerFunc, middlewares ...Middleware) http.HandlerFunc {
  54.    for _, m := range middlewares {
  55.       f = m(f)
  56.    }
  57.    return f
  58. }
  60. func Hello(w http.ResponseWriter, r *http.Request) {
  61.    fmt.Fprintln(w, "hello world")
  62. }
  64. func main() {
  65.    http.HandleFunc("/", Chain(Hello, Method("GET"), Logging()))
  66.    http.ListenAndServe(":8080", nil)
  67. }

中间件本身只是将其http.HandlerFunc作为其参数之一，包装它并返回一个新http.HandlerFunc的服务器来调用。在这里，我们定义了一种新类型Middleware，最终可以更容易地将多个中间件链接在一起。

当然我们也可以改成如下形式

  1. package main
  3. import (
  4.    "fmt"
  5.    "log"
  6.    "net/http"
  7.    "time"
  8. )
  10. type Middleware func(http.Handler) http.Handler
  12. func Hello(w http.ResponseWriter, r *http.Request) {
  13.    fmt.Fprintln(w, "hello world")
  14. }
  16. func Chain(f http.Handler, mmap ...Middleware) http.Handler {
  17.    for _, m := range mmap {
  18.       f = m(f)
  19.    }
  20.    return f
  21. }
  22. func Method(m string) Middleware {
  23.    return func(f http.Handler) http.Handler {
  24.       return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  25.          log.Println(r.URL.Path)
  26.          if r.Method != m {
  27.             http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
  28.             return
  29.          }
  30.          f.ServeHTTP(w, r)
  31.       })
  32.    }
  34. }
  35. func Logging() Middleware {
  36.    return func(f http.Handler) http.Handler {
  37.       return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  38.          //log.Println(r.URL.Path)
  39.          // Do middleware things
  40.          start := time.Now()
  41.          defer func() { log.Println(r.URL.Path, time.Since(start)) }()
  42.          f.ServeHTTP(w, r)
  43.       })
  44.    }
  45. }
  47. func main() {
  48.    http.Handle("/", Chain(http.HandlerFunc(Hello), Method("GET"), Logging()))
  49.    http.ListenAndServe(":8080", nil)
  50. }

在gin框架下实现中间件

  1. r := gin.Default() 创建带有默认中间件的路由，默认是包含logger和recovery中间件的
  2. r :=gin.new()      创建带有没有中间件的路由

示例

  1. package main
  3. import (
  4.    "github.com/gin-gonic/gin"
  5.    "log"
  6.    "time"
  7. )
  9. func Logger() gin.HandlerFunc {
  10.    return func(c *gin.Context) {
  11.       t := time.Now()
  12.       // Set example variable
  13.       c.Set("example", "12345")
  14.       // before request
  15.       c.Next()
  16.       // after request
  17.       latency := time.Since(t)
  18.       log.Print(latency) //时间  0s
  19.       // access the status we are sending
  20.       status := c.Writer.Status()
  21.       log.Println(status) //状态 200
  22.    }
  23. }
  24. func main() {
  25.    r := gin.New()
  26.    r.Use(Logger())
  28.    r.GET("/test", func(c *gin.Context) {
  29.       example := c.MustGet("example").(string)
  31.       // it would print: "12345"
  32.       log.Println(example)
  33.    })
  35.    // Listen and serve on 0.0.0.0:8080
  36.    r.Run(":8080")
  37. }

以上示例也可改为

  1. package main
  3. import (
  4.     "github.com/gin-gonic/gin"
  5.     "log"
  6.     "time"
  7. )
  9. func Logger(c *gin.Context)  {
  10.         t := time.Now()
  11.         // Set example variable
  12.         c.Set("example", "12345")
  13.         // before request
  14.         c.Next()
  15.         // after request
  16.         latency := time.Since(t)
  17.         log.Print(latency) //时间  0s
  18.         // access the status we are sending
  19.         status := c.Writer.Status()
  20.         log.Println(status) //状态 200
  22. }
  23. func main() {
  24.     r := gin.New()
  25.     r.Use(Logger)
  27.     r.GET("/test", func(c *gin.Context) {
  28.         example := c.MustGet("example").(string)
  30.         // it would print: "12345"
  31.         log.Println(example)
  32.     })
  34.     // Listen and serve on 0.0.0.0:8080
  35.     r.Run(":8080")
  36. }

以上示例也可改为

  1. package main
  3. import (
  4.    "github.com/gin-gonic/gin"
  5.    "log"
  6.    "time"
  7. )
  9. func Logger() gin.HandlerFunc {
  10.    return func(c *gin.Context) {
  11.       t := time.Now()
  12.       // Set example variable
  13.       c.Set("example", "12345")
  14.       // before request
  15.       c.Next()
  16.       // after request
  17.       latency := time.Since(t)
  18.       log.Print(latency) //时间  0s
  19.       // access the status we are sending
  20.       status := c.Writer.Status()
  21.       log.Println(status) //状态 200
  22.    }
  23. }
  25. func main() {
  26.    r := gin.New()
  27.    r.GET("/test", Logger(), func(c *gin.Context) {
  28.       example := c.MustGet("example").(string)
  29.       // it would print: "12345"
  30.       log.Println(example)
  31.    })
  32.    // Listen and serve on 0.0.0.0:8080
  33.    r.Run(":8080")
  34. }

即不用r.use添加中间件，直接将Logger() 写到r.GET 方法的参数里（”/test”之后）。

更多gin中间件示例可参考 https://github.com/gin-gonic/gin

参考资料

https://drstearns.github.io/tutorials/gomiddleware/

https://gowebexamples.com/advanced-middleware/

links