1. 无中间件启动

  1. #使用
  2. r := gin.New()
  3. #替代
  4. // 默认启动方式，包含 Logger、Recovery 中间件
  5. r := gin.Default()

2. 使用中间件

  1. func main() {
  2.     // 创建一个不包含中间件的路由器
  3.     r := gin.New()
  5.     // 全局中间件
  6.     // 使用 Logger 中间件
  7.     r.Use(gin.Logger())
  9.     // 使用 Recovery 中间件
  10.     r.Use(gin.Recovery())
  12.     // 路由添加中间件，可以添加任意多个
  13.     r.GET("/benchmark", MyBenchLogger(), benchEndpoint)
  15.     // 路由组中添加中间件
  16.     // authorized := r.Group("/", AuthRequired())
  17.     // exactly the same as:
  18.     authorized := r.Group("/")
  19.     // per group middleware! in this case we use the custom created
  20.     // AuthRequired() middleware just in the "authorized" group.
  21.     authorized.Use(AuthRequired())
  22.     {
  23.         authorized.POST("/login", loginEndpoint)
  24.         authorized.POST("/submit", submitEndpoint)
  25.         authorized.POST("/read", readEndpoint)
  27.         // nested group
  28.         testing := authorized.Group("testing")
  29.         testing.GET("/analytics", analyticsEndpoint)
  30.     }
  32.     // Listen and serve on 0.0.0.0:8080
  33.     r.Run(":8080")
  34. }

3. 自定义组件

  1. func Logger() gin.HandlerFunc {
  2.     return func(c *gin.Context) {
  3.         t := time.Now()
  5.         // Set example variable
  6.         c.Set("example", "12345")
  8.         // before request
  10.         c.Next()
  12.         // after request
  13.         latency := time.Since(t)
  14.         log.Print(latency)
  16.         // access the status we are sending
  17.         status := c.Writer.Status()
  18.         log.Println(status)
  19.     }
  20. }
  22. func main() {
  23.     r := gin.New()
  24.     r.Use(Logger())
  26.     r.GET("/test", func(c *gin.Context) {
  27.         example := c.MustGet("example").(string)
  29.         // it would print: "12345"
  30.         log.Println(example)
  31.     })
  33.     // Listen and serve on 0.0.0.0:8080
  34.     r.Run(":8080")
  35. }