Go语言中的gin框架之【GET/POST】请求参数接收传值（五）

Gin中的get和post指的是HTTP请求中的不同方法。当客户端向服务器发起HTTP GET请求时，服务器会将相应的资源返回给客户端；当客户端向服务器发起HTTP POST请求时，服务器会将客户端发送的数据作为请求的一部分处理。

Gin是Go语言编写的一个Web框架，它支持HTTP GET和HTTP Post请求。通常情况下，HTTP GET用于请求数据或资源，而HTTP POST用于向服务器提交数据，比如Web表单。

在Gin中，我们可以使用GET方法来声明一个HTTP Get请求的处理器，例如以下代码：

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/hello", func(c *gin.Context) {
        c.String(200, "Hello, Gin!")
    })

    r.Run() // 启动服务器
}

在上面的例子中，我们声明了一个HTTP Get请求的处理器，它的路由路径是“/hello”，当客户端向服务器发送“/hello”的GET请求时，则会执行此处理器。

这里的Get请求是在没有参数的情况下的一个案例，实际业务中可能有多样性的请求，所以，我们这里补充一下，在GET请求中还有一种类似于（localhost:8080/login?username="xiaomi"&password="123456"）这样的访问url链接时候，在路由中如何取值呢？

也就是服务端如何接收 URL链接上参数？

在Gin中，可以使用Param或Query方法获取URL中的查询参数。Param方法可以获取路径参数，而Query方法可以获取查询参数。

例如：

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    // /book/123  动态路由
    r.GET("/book/:id", func(c *gin.Context) {
        id := c.Param("id")
        c.String(200, "Book ID is "+id)
    })

    // /search?query=gin  路由携带参数
    r.GET("/search", func(c *gin.Context) {
        query := c.Query("query")
        c.String(200, "Search query is "+query)
    })

    r.Run()
}

在上面的例子中，我们使用Param方法获取路径参数，通过**":id"来指定参数名，在处理器函数中使用c.Param(“id”)获取参数值，最后返回给客户端。我们也使用Query方法获取查询参数，使用"c.Query(“query”)"获取名为"query"的参数值**，最后返回给客户端。

这里我们需要注意的是 Param() 和Query（）方法的首写字母都是大写， 同时，这两个方法都是

【**c *gin.Context**】c对象的内置方法。

此外，我们也可以使用POST方法来声明一个HTTP Post请求的处理器，例如以下代码：

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.POST("/login", func(c *gin.Context) {
        username := c.PostForm("username")
        password := c.PostForm("password")

        // 进行用户验证操作

        c.String(200, "登录成功！")
    })

    r.Run() // 启动服务器
}

在上面的例子中，我们声明了一个HTTP Post请求的处理器，它的路由路径是“/login”，当客户端向服务器发送“/login”的POST请求时，则会执行此处理器。在处理器中，我们可以通过c.PostForm方法获取客户端提交的表单数据，并进行相应的处理。

补充说明，在post请求模拟登录或者注册请求时候是结构体的数据，我们需要从请求c.request.body中获取到请求参数处理完成后，返回给客户端（这里不管是否成功与否的情况，这样的状态都一样要处理一下与实际开发环境一致）。如下案例：

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

// 定义一个 userinfo 表单结构体对象
type UserInfo struct {
    UserName string `json:"username" form:"username"`
    Password string `json:"password" form:"password"`
    Age      string `json:"age" form:"age"`
}

func main() {
    // 定义一个路由引擎对象
    router := gin.Default()

    // 加载 渲染模板 全局
    router.LoadHTMLGlob("*templates/**/*")

    // 路由 get请求后 返回数据到模板渲染
    router.GET("/", func(c *gin.Context) {
        // c.JSON(200, gin.H{
        //     "message": "Hello, world!",
        // })
        c.HTML(http.StatusOK, "login/index.html", gin.H{
            "title":   "登录页面",
            "content": "这是一个",
        })
    })

    // get请求 c.Query（）方法获取url【/login?usename="小红"&password="123123"】 上的参数值：
    router.GET("/login", func(c *gin.Context) {
        username := c.Query("username")
        password := c.Query("password")
        // c.DefaultQuery()方法可以设定默认值，触发的条件是如果获取不到url上这个age参数的值，就返回约定的默认值18
        age := c.DefaultQuery("age", "18") // 18 is default value for login form auth form auth

        // 获取到url传入的参数跳转到 新的页面 首页 渲染到、default/index.html
        c.HTML(http.StatusOK, "default/index.html", gin.H{
            "name":     username,
            "password": password,
            "age":      age,
        })
    })

    // GET / 动态路由链接  /logout/1233 其中的1233是这个url上的动态变量值,默认取值就是uid
    router.GET("/logout/:uid", func(c *gin.Context) {
        uid := c.Param("uid") // 获取动态路由url链接上的变量值 /logout/1233 这里的值为1233
        status := "登出成功"
        // c.String(http.StatusOK, "uid=%v 状态=%v", uid, status)
        c.JSON(http.StatusOK, gin.H{
            "status": status,
            "uid":    uid,
        })
    })

    // 赋值结构体
    router.GET("/register", func(ctx *gin.Context) {
        // ctx.String(http.StatusOK,"成功！！")
        ctx.HTML(http.StatusOK, "register/index.html", gin.H{})

    })
    router.POST("/doAdd", func(ctx *gin.Context) {
        // post请求通过 c.PostForm()方法获取表单数据
        // username := ctx.PostForm("username")
        // password := ctx.PostForm("password")
        // age := ctx.DefaultPostForm("age", "20")
        // ctx.JSON(http.StatusOK, gin.H{
        //     "username": username,
        //     "password": password,
        //     "age":      age,
        // })

        // post请求 通过  ctx.ShouldBind(&userInfo) 方法  结构体赋值
        userInfo := &UserInfo{}
        if err := ctx.ShouldBind(&userInfo); err == nil {
            ctx.JSON(http.StatusOK, gin.H{
                "userInfn": userInfo,
            })
        } else {
            ctx.JSON(http.StatusBadRequest, gin.H{
                "error": err.Error(),
            })
        }
    })

    router.Run(":8080")
}

其中html页面 default、login、register 文件夹等等只展示一下图片文件结构；

{{define "register/index.html"}}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>注册页面</title>
</head>
    <h1>{{"注册页面"}}</h1>
    <form action="/doAdd" method="post">
        用户名 <input type="text" name="username" id="username">
        密码 <input type="text" name="password" id="password">
        年龄  <input type="text" name="age" id="age">
        <input type="submit" value="提交">
    </form>
</body>
</html>
{{end}}

我们可以使用

ShouldBind

方法将请求中的数据绑定到结构体对象上。假设我们的请求体是 JSON 格式的数据，我们可以将它绑定到结构体对象上，步骤如下：

1.定义结构体

type User struct {
    Name     string `json:"name"`
    Age      int    `json:"age"`
    Password string `json:"password"`
}

2.使用

ShouldBind

方法

func handlePostRequest(c *gin.Context) {
    var user User
    if err := c.ShouldBind(&user); err != nil {
        c.AbortWithError(http.StatusBadRequest, err)
        return
    }
    c.JSON(http.StatusOK, gin.H{
        "name":     user.Name,
        "age":      user.Age,
        "password": user.Password,
    })
}

在上面的示例中，定义了一个结构体

User

，表示请求体中的数据格式。然后使用

ShouldBind

方法将请求体的数据绑定到

User

对象中，并判断是否绑定失败。

ShouldBind

方法可以自动根据 Content-Type 的不同进行不同类型的绑定，支持 JSON、XML、Form 四种数据类型。需要注意的是，与使用

Bind

方法不同，如果使用

ShouldBind

方法失败，则不会抛出异常，而是返回错误对象。如果需要抛出异常，可以使用

ShouldBindJSON

或

ShouldBindXML

方法。

此外，还可以使用

ShouldBindUri

方法将 URL 中的数据绑定到结构体对象上。该方法与

ShouldBind

方法的用法类似。比如：

func handleGetRequest(c *gin.Context) {
    var user User
    if err := c.ShouldBindUri(&user); err != nil {
        c.AbortWithError(http.StatusBadRequest, err)
        return
    }
    c.JSON(http.StatusOK, gin.H{
        "name": user.Name,
        "age":  user.Age,
    })
}

在上面的示例中，我们使用

ShouldBindUri

方法将 URL 中的数据绑定到

User

对象中，然后返回

User

对象中的部分数据到客户端。

这里就贴出了最后关于简单注册的html代码其他可以移步到资源下载一下

以上就是使用Gin框架进行post和get请求的基本步骤。通过学习这些基础知识，可以进一步学习如何使用路由跳转等高级功能来满足更多实际需求。