Go语言框架Gin基础教程三：参数接收

## 简介

在 `Web` 开发中，接收用户传递的参数是一项基本的任务。`Gin` 提供了多种方式来处理 `HTTP` 请求并解析参数，本文将介绍使用 `Gin` 框架接收参数的几种常见方法。

<!-- more -->

## 参数分类

参数传递的方式不同，就意味着需要使用不同的参数接收方式，本文按照参数传递的方式对参数进行分类：
1. `Query` 参数
2. `URL` 参数
3. `POST` 表单(`form-data`)参数
4. `JSON` 参数
5. `Header` 参数

接下来，将依次讲解这几种参数的接受方式。

## Query 参数

`Query` 参数是最常见的 `URL` 传参方式，最常见通常也意味着最不安全，所以该传参方法常用于传递安全性要求较低的查询参数，所以可称之为 `Query` 参数。

`Gin` 允许通过 `Query` 方法来获取 `URL` 中的查询参数。下面是一个简单的例子：

在上篇文章介绍的 `HelloController,go` 中增加以下代码：
```go
func HelloQuery(c *gin.Context) {
    // 获取名为 "name" 的查询参数
    name := c.Query("name")
    
    // 为了便于观察接口调用情况，此处返回一些信息，本文不做讲解，将在下一篇文章详细介绍
    c.String(http.StatusOK, "Hello %s", name)
}
```
在 `main.go` 中增加以下代码：
```go
api.GET("/helloQuery", controller.HelloQuery)
```

在上面的例子中，通过 `c.Query("name")` 方法获取名为 `name` 的查询参数，并返回一个包含参数值的字符串。

### 测试

`http://localhost:8080/gin/helloQuery?name=dingdangdog`

![query](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1712658971559.jpg)

## URL 参数
除了查询参数，有时我们需要从 `URL` 节点中获取参数。`Gin` 允许通过定义路由参数来实现这一点。
> PS：虽然它与 `Query` 方式都是通过URL传参，但是本方式对于用户来说，更有隐蔽性。

示例：`HelloController,go` 增加：
```go
func HelloUrl(c *gin.Context) {
    // 获取名为 "name" 的路由参数
    name := c.Param("name")
    c.String(http.StatusOK, "Hello %s", name)
}
```

`main.go` 增加：
```go
api.GET("/helloUrl/:name", controller.HelloUrl)
```

在上面的例子中，使用 `:name` 定义了一个路由参数，可以通过 `c.Param("name")` 方法获取该参数的值。

### 测试

`http://localhost:8080/gin/helloUrl/dingdangdog`

![url](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1712658980947.jpg)

## POST 表单参数
在处理 `POST` 请求时，有时我们需要接收表单参数。`Gin` 允许使用 `PostForm` 方法来获取 `POST` 表单中的参数。

示例：`HelloController,go` 增加：
```go
func HelloPost(c *gin.Context) {
    // 获取名为 "name" 的表单参数
    name := c.PostForm("name")
    c.String(http.StatusOK, "Hello %s", name)
}
```

`main.go` 增加：
```go
api.POST("/helloPost", controller.HelloPost)
```

### 测试

- URL：`http://localhost:8080/gin/helloPost`
- 参数：`name: dingdangdog`

![post](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1712658985126.jpg)

## JSON 参数
另一种常见的场景是接收 `JSON` 格式的参数，这种传参也需要 `Post` 方式传递。`Gin` 提供了 `ShouldBindJSON` 方法来解析 `JSON` 参数并绑定到结构体。

示例：`HelloController,go` 增加：
```go
type User struct {
    Name string `json:"name"`
}

func HelloJson(c *gin.Context) {
    var user User
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    c.String(http.StatusOK, "Hello %s", user.Name)
}
```

`main.go` 增加：
```go
api.POST("/helloJson", controller.HelloJson)
```

在上面的例子中，定义了一个 `User` 结构体，通过 `ShouldBindJSON` 方法将 `JSON` 参数解析到该结构体中。

### 测试

- URL：`http://localhost:8080/gin/helloJson`
- 参数：`{"name": "dingdangdog"}`

![json](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1712658987919.jpg)

## Header 参数
`Http Header` 虽然一般不会用于参数传递，但当然也可以用于参数传递（`谁说Token不算参数！`）。

示例：`HelloController,go` 增加：
```go
func HelloHeader(c *gin.Context) {
    name := c.GetHeader("name")
    c.String(http.StatusOK, "Hello %s", name)
}
```

`main.go` 增加：
```go
api.GET("/helloHeader", controller.HelloHeader)
```

在上面的例子中，定义了一个 `User` 结构体，通过 `ShouldBindJSON` 方法将 `JSON` 参数解析到该结构体中。

### 测试

- URL：`http://localhost:8080/gin/helloHeader`
- Header：`name: dingdangdog`

![header](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1712658991146.jpg)

## 最终代码

`main.go`：
```go
package main

// 引用 fmt 和 gin
import (
    "fmt"
    "github.com/gin-gonic/gin"
    "gin-server/controller"
)

func main() {
    // 创建路由
    router := gin.Default()
        
    // 路由分组
    api := router.Group("/gin")
    // 开放接口
    api.GET("/hello", controller.Hello)
    api.GET("/helloQuery", controller.HelloQuery)
    api.GET("/helloUrl/:name", controller.HelloUrl)
    api.POST("/helloPost", controller.HelloPost)
    api.POST("/helloJson", controller.HelloJson)
    api.GET("/helloHeader", controller.HelloHeader)
    // 启动服务并设置端口为 8080
    err := router.Run(":8080")
    if err != nil {
        fmt.Println("Error: ", err)
    }
}
```

`HelloController.go`：
```go
package controller


import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)

// 接口参数必须是 c *gin.Context
func Hello(c *gin.Context) {
    fmt.Println("hello gin")
}


func HelloQuery(c *gin.Context) {
    // 获取名为 "name" 的查询参数
    name := c.Query("name")
    
    // 为了便于观察接口调用情况，此处返回一些信息，本文不做讲解，将在下一篇文章详细介绍
    c.String(http.StatusOK, "Hello %s", name)
}


func HelloUrl(c *gin.Context) {
    // 获取名为 "name" 的路由参数
    name := c.Param("name")
    c.String(http.StatusOK, "Hello %s", name)
}

func HelloPost(c *gin.Context) {
    // 获取名为 "name" 的表单参数
    name := c.PostForm("name")
    c.String(http.StatusOK, "Hello %s", name)
}

type User struct {
    Name string `json:"name"`
}

func HelloJson(c *gin.Context) {
    var user User
    if err := c.ShouldBindJSON(&user); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    c.String(http.StatusOK, "Hello %s", user.Name)
}

func HelloHeader(c *gin.Context) {
    name := c.GetHeader("name")
    c.String(http.StatusOK, "Hello %s", name)
}
```

## 总结

以上是使用 Gin 框架接收参数的几种常见方法。根据不同的需求，选择合适的方法来处理参数可以使代码更加清晰和高效。
1. `c.Query("name")` 接收 Query 参数；
2. `c.Param("name")` 接收 URL 参数；
3. `c.PostForm("name")` 接收 Post-formdata 参数；
4. `c.ShouldBindJSON(&user)` 接收 Post-Json 参数，建议定义结构体接收；
5. `c.GetHeader("name")` 接收 Header 参数。
6. 使用`http.StatusOK`需要引入 `net/http`包
7. 测试 `Post` 请求或自定义 `Header` 时，浏览器无法直接测试，可以使用测试工具，如：`Postman`等。

通过以上学习，你已经学会了使用 `Gin` 接收 `Http` 请求时，获取请求参数的几乎所有用得到的操作，接下来将会讲解自定义响应相关的操作，敬请期待……

## 赞助请求V3

**建站因为热爱，生活需要Money，请屏幕前的大佬动动您发财的小手，点击一次以示鼓励，祝您生活愉快！**

<!-- 文章内嵌广告位 -->
<div class="article-ads"></div>

> PS：就目前的访问量，即便每个访客都点一次广告，收入也不足以支付运营成本。`如果看不到广告，可能是网络原因或被拦截了，那就算了吧。再次祝您生活愉快~~`