Golang 关于Gin框架请求参数的获取方法_Golang

gin框架请求参数的获取

gin是一个用go语言编写的web框架，它提供了强大的路由和中间件功能，使得开发web应用变得更加简单和高效。
在使用gin框架开发web应用时，处理请求参数是一个非常重要的环节。本文将结合实际案例，详细介绍在go语言中如何使用gin框架处理请求参数。

一、请求参数的类型和位置

在http请求中，参数可以通过多种方式传递，常见的类型包括：

url path参数：参数直接写在请求路径中，例如/user/:id。
url query参数：参数跟在url的?后面，以键值对的形式传递，多个参数之间用&分隔，例如/user/list?name=john&gender=男。
http body参数：参数在请求体中传递，通常用于post、put等请求方法，内容格式可以是json、xml等。
header参数：参数在http请求头中传递，例如content-type、accept等。

二、获取请求参数的方法

gin框架提供了多种方法来获取请求参数，包括直接获取和绑定到结构体中两种方式。

1. 直接获取请求参数

（1）获取url path参数

url path参数是指直接写在请求路径中的参数，可以通过gin框架的param方法获取。
后台获取路径请求参数通过ctx.param(“参数名”) 来获取

示例代码：

package main
import (
    "github.com/gin-gonic/gin"
    "net/http"
)
func main() {
    engine := gin.default()
    //请求参数 用:变量名 表示
    engine.get("/user/:id", func(ctx *gin.context) {
        //后台获取请求参数通过ctx.param("参数名") 来获取
        id := ctx.param("id")
        //响应到页面
        //fmt.fprintf(ctx.writer, "你的请求id: %s", id)
        ctx.string(http.statusok, "您的id是%s", id)
    })
    engine.run()
}

运行后，发起请求http://localhost:8080/user/100，会返回你的请求id: 100。

（2）获取url query参数

url query参数是指跟在url的?后面的键值对集合，可以通过gin框架的query、defaultquery、queryarray、querymap等方法获取。

示例代码：

package main
import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)
func main() {
    engine := gin.default()
    engine.get("/user/list", func(ctx *gin.context) {
        name := ctx.query("name")
        gender := ctx.defaultquery("gender", "男")
        habits := ctx.queryarray("habits")
        fmt.printf("name: %s, gender: %s, habits: %v\n", name, gender, habits)
        works := ctx.querymap("works")
        //响应到页面
        ctx.string(http.statusok, "%s, %s, %v, %s\n", name, gender, habits, works)
    })
    engine.run(":8080")
}

运行后，浏览器发起请求
http://127.0.0.1:8080/user/list?name=john&gender=男&habits=reading&habits=sports&works[teacher]=math&works[engineer]=computer
会返回 john, 男, [reading sports], map[engineer:computer teacher:math]

（3）获取http body参数

http body参数是指请求体中的参数，通常用于post、put等请求方法。可以通过gin框架的postform、defaultpostform、postformarray、postformmap等方法获取。

示例代码：

package main
import (
    "fmt"
    "github.com/gin-gonic/gin"
)
func main() {
    engine := gin.default()
    //使用post请求
    engine.post("/user/add", func(ctx *gin.context) {
        name := ctx.postform("name")
        gender := ctx.defaultpostform("gender", "男")
        //获取切片数据
        habits := ctx.postformarray("habits")
        //获取map数据
        works := ctx.postformmap("works")
        fmt.printf("%s, %s, %v, %s\n", name, gender, habits, works)
    })
    engine.run()
}

postman发请求

（4）获取header参数

header参数是指http请求头中的参数，可以通过gin框架的getheader方法获取。

示例代码：

package main
import (
    "github.com/gin-gonic/gin"
    "net/http"
)
func main() {
    engine := gin.default()
    engine.post("/getheader", func(ctx *gin.context) {
        //拿到请求头参数数据
        useragent := ctx.getheader("user-agent")
        ctx.string(http.statusok, "user-agent: %s", useragent)
    })
    engine.run()
}

2. 绑定请求参数到结构体

gin框架支持将请求参数自动绑定到结构体中，这样可以更方便地进行参数验证和处理。绑定参数的方法包括bind、shouldbind、bindjson、bindquery等。

（1）绑定url query参数到结构体

示例代码：

package main
import (
    "github.com/gin-gonic/gin"
    "net/http"
)
// user 定义结构体，使用form标签指定参数名，以便正确地绑定参数 get请求使用功能form标签
type user struct {
    id    int64  `form:"id"`
    name  string `form:"name"`
    age   int    `form:"age"`
    email string `form:"email"`
}
func main() {
    engine := gin.default()
    engine.get("/user/info", func(ctx *gin.context) {
        var user user
        //将结构体对象指针传进去
        if err := ctx.shouldbindquery(&user); err != nil {
            ctx.json(http.statusbadrequest, gin.h{"error": err.error()})
            return
        }
        //以json字符串的方式响应给客户端这个结构体对象
        ctx.json(http.statusok, user)
    })
    engine.run()
}

（2）绑定http body参数到结构体（json格式）

当前端请求的数据通过json提交时，例如向/json发送一个post请求

示例代码：

package main
import (
    "github.com/gin-gonic/gin"
    "net/http"
)
// user 绑定http body参数到结构体 ，创建结构体时需要用json标签
type user struct {
    id    int64  `json:"id"`
    name  string `json:"name"`
    age   int    `json:"age"`
    email string `json:"email"`
}
func main() {
    engine := gin.default()
    engine.post("/user/add", func(ctx *gin.context) {
        var user user
        // ctx.shouldbindjson(&user) 将结构体指针传进去
        if err := ctx.shouldbindjson(&user); err != nil {
            ctx.json(http.statusbadrequest, gin.h{"error": err.error()})
            return
        }
        //响应给客户端结构体
        ctx.json(http.statusok, user)
    })
    engine.run()
}

也可以直接获取原生json数据处理

package main
import (
    "encoding/json"
    "github.com/gin-gonic/gin"
    "net/http"
)
func main() {
    engine := gin.default()
    engine.post("/json", func(ctx *gin.context) {
        // getrawdata : 从c.request.body读取请求数据, 返回 []byte
        // func (c *context) getrawdata() ([]byte, error)
        b, _ := ctx.getrawdata()
        // 定义map或结构体接收
        var m map[string]interface{}
        // 将接收的b json反序列化为map数据
        _ = json.unmarshal(b, &m)
        ctx.json(http.statusok, m)
    })
    engine.run()
}