文档

使用技巧

HTTP method

GET方法

  • GET方法用于从服务器获取资源，通常用于查询数据。在Gin中，可以使用GET方法来定义路由和处理函数，例如：

    1
    2
    3
    r.GET("/users", func(c *gin.Context) {
        // 处理获取用户列表的逻辑
    })

POST方法

  • POST方法用于向服务器提交数据，通常用于创建新资源。在Gin中，可以使用POST方法来定义路由和处理函数，例如：

    1
    2
    3
    r.POST("/users", func(c *gin.Context) {
        // 处理创建新用户的逻辑
    })

PUT方法

  • PUT方法用于向服务器更新资源，通常用于更新已有资源。在Gin中，可以使用PUT方法来定义路由和处理函数，例如：

    1
    2
    3
    r.PUT("/users/:id", func(c *gin.Context) {
        // 处理更新用户信息的逻辑
    })

PATCH方法

  • PATCH方法用于向服务器部分更新资源，通常用于更新已有资源的一部分。在Gin中，可以使用PATCH方法来定义路由和处理函数，例如：

    1
    2
    3
    r.PATCH("/users/:id", func(c *gin.Context) {
        // 处理部分更新用户信息的逻辑
    })

DELETE方法

  • DELETE方法用于从服务器删除资源，通常用于删除已有资源。在Gin中，可以使用DELETE方法来定义路由和处理函数，例如：

    1
    2
    3
    r.DELETE("/users/:id", func(c *gin.Context) {
        // 处理删除用户的逻辑
    })

OPTIONS方法

  • OPTIONS方法用于获取服务器支持的HTTP方法和其他选项。在Gin中，可以使用OPTIONS方法来定义路由和处理函数，例如：

    1
    2
    3
    r.OPTIONS("/users", func(c *gin.Context) {
        // 处理获取服务器支持的选项的逻辑
    })

HEAD方法

  • HEAD方法与GET方法类似，但不返回响应体，只返回响应头信息。在Gin中，可以使用HEAD方法来定义路由和处理函数，例如：

    1
    2
    3
    r.HEAD("/users/:id", func(c *gin.Context) {
        // 处理获取用户信息的逻辑，但不返回响应体
    })

TRACE方法

  • TRACE方法用于在请求路径上返回服务器收到的原始请求信息，用于诊断和调试。在Gin中，可以使用TRACE方法来定义路由和处理函数，例如：

    1
    2
    3
    r.TRACE("/debug", func(c *gin.Context) {
        // 处理返回原始请求信息的逻辑
    })

gin.Context

MustGet

  • 使用场景

    1. 在中间件中获取在之前的中间件或处理程序中设置的值。例如，可以在身份验证中间件中获取用户信息，以确保用户已经通过身份验证

      1
      2
      3
      4
      5
      6
      7
      func AuthMiddleware() gin.HandlerFunc {
          return func(c *gin.Context) {
              user := c.MustGet("user").(*User)
              // 进行身份验证逻辑
            	c.Next()
          }
      }

    2. 在处理程序中获取在路由处理程序之前设置的值。例如，可以在一个处理程序中获取URL参数或路由参数

      1
      2
      3
      4
      5
      func GetUserHandler(c *gin.Context) {
          userID := c.MustGet("userID").(int)
          // 根据userID获取用户信息
          c.JSON(http.StatusOK, gin.H{"userID": userID})
      }

  • 注意点

    • MustGet方法在获取值时会进行断言，如果断言失败会引发panic。因此，必须确保在使用MustGet方法之前，已经在上下文中设置了相应的值
    • 在实际使用中，应该谨慎使用MustGet方法，避免滥用panic。如果不确定是否能获取到值，可以使用Get方法进行安全的获取，并检查返回的结果是否为nil

ShouldBind*

  • ShouldBindUri

    1
    2
    3
    4
    type MyId struct {
        ID uint `uri:"id" binding:"required"`
    }
    router.POST(":id", handler)

  • ShouldBindQuery

    1
    2
    3
    4
    5
    type MyInfo struct {
    	name  string `form:"name"`
    	email string `form:"email"`
    }
    router.Get("", handler)

  • ShouldBindJson

    1
    2
    3
    4
    5
    type MyInfo struct {
    	name  string `json:"name" binding:"required"`
    	email string `json:"email" binding:"required"`
    }
    router.POST("", handler)

middleware

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
func main() {
    router := gin.Default()

    // 添加全局中间件
    // 每个请求到达服务器时都会执行该函数
    router.Use(loggerMiddleware)

    // 定义GET请求的路由规则，并传递多个handler函数
    router.GET("/hello", handlerA, handlerB)
  
    // 局部中间件
    router.GET("/health", middlewareA, middlewareB, handler)

    router.Run(":8080")
}

// 中间件函数
func loggerMiddleware(c *gin.Context) {
    // 记录请求日志
    log.Println("Request received:", c.Request.Method, c.Request.URL.Path)

    // 执行后续的handler函数
    c.Next()
}

// 第一个handler函数
func handlerA(c *gin.Context) {
    // 处理请求的逻辑
}

// 第二个handler函数
func handlerB(c *gin.Context) {
    // 处理请求的逻辑
}