面向切面开发，类比python的装饰器

全局中间件

所有请求都经过此中间件

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6.     "github.com/gin-goinc/gin"
  7. )
  9. // define middleware
  10. func Middleware() gin.HandlerFunc {
  11.     return func(c *gin.Context) {
  12.         t := time.Now()
  13.         fmt.Println("middleware start")
  14.         // set variable into Context
  15.         c.Set("foo", "bar")
  16.         status := c.Writer.Status()
  17.         fmt.Println("middleware finish", status)
  18.         t2 := time.Since(t)
  19.         fmt.Println("time:", t2)
  20.     }
  21. }
  23. func main() {
  24.     r := gin.Default()
  25.     r.Use(Middleware())
  26.     {
  27.         r.GET("/test", func(c *gin.Context) {
  28.             // get variable
  29.             req, _ := c.Get("foo")
  30.             fmt.Println("foo", req)
  31.             c.JSON(200, gin.H{"foo": req})
  32.         })
  33.     }
  35.     r.Run()
  36. }

输出

  1. middleware start
  2. middleware finish
  3. time: 0 s
  4. foo: bar

代码中计算时间差没有执行？（我感觉是执行了，先把中间件里面的都走完，再走具体的函数）

Next()方法

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6.     "github.com/gin-goinc/gin"
  7. )
  9. // define midlleware 
  10. func MiddleWare() gin.HandlerFunc {
  11.     return func(c *gin.Context) {
  12.         t := time.Now()
  13.         fmt.Println("middleware start")
  14.         // set variable 
  15.         c.Set("foo", "bar")
  16.         // execute function
  17.         c.Next()
  18.         // something execute after function
  19.         status := c.Writer.Status()
  20.         fmt.Println("middleware finsih", status)
  21.         t2 := time.Since(t)
  22.         fmt.Println("time:", t2)
  23.     }
  24. }
  26. func main() {
  27.     r := gin.Default()
  28.     r.Use(MiddleWare())
  29.     {
  30.         r.GET("/test", func(c *gin.Context) {
  31.             req, _ := c.Get("foo")
  32.             fmt.Println("foo:", req)
  33.             c.JSON(200, gin.H{"foo:": req})
  34.         })
  35.     }
  37.     r.Run()
  38. }

输出

  1. middleware start
  2. foo: bar
  3. middleware finish
  4. time: 998.6 μs

走到先走中间件的前几句，遇到Next()转而去执行具体的函数，执行完回来继续执行剩余的中间件代码，类似 中断操作？

局部中间件

与全局中间不同的地方在于使用方式，定义是一样的

  1. package main
  2. import (
  3.     "fmt"
  4.     "time"
  5.     "github.com/gin-gonic/gin"
  6. )
  7. // define middleware
  8. func MiddleWare() gin.HandlerFunc {
  9.     return func(c *gin.Context) {
  10.         t := time.Now()
  11.         fmt.Println("middleware start")
  12.         c.Set("foo", "bar")
  13.         c.Next()
  14.         status := c.Writer.Status()
  15.         fmt.Println("middleware finsih", status)
  16.         t2 := time.Since(t)
  17.         fmt.Println("time:", t2)
  18.     }
  19. }
  21. func main() {
  22.     r := gin.Default()
  23.     // 中间件在局部使用
  24.     r.GET("/text", Middleware(), func(c *gin.Context) {
  25.         req, _ := c.Get("foo")
  26.         fmt.Println("foo:", req)
  27.         c.JSON(200, gin.H{"foo": bar})
  28.     })
  29.     r.Run()
  30. }