请求处理：参数绑定与验证

本篇是 Gin 系列教程的第三篇。上一篇我们学会了用 c.Query、c.PostForm、c.Param 一个个手动读取参数。本篇将引入更工程化的方式——参数绑定（Binding）：把请求里的零散参数一次性映射到结构体，并配合 binding 标签做校验。这是实际项目中最常用、也最推荐的处理方式。

一、为什么要用参数绑定

先看一段「手动读取」的代码：

r.POST("/register", func(c *gin.Context) {
	username := c.PostForm("username")
	password := c.PostForm("password")
	email := c.PostForm("email")
	ageStr := c.PostForm("age")

	// 1. 校验非空
	if username == "" || password == "" || email == "" {
		c.JSON(400, gin.H{"error": "字段不能为空"})
		return
	}
	// 2. 类型转换
	age, err := strconv.Atoi(ageStr)
	if err != nil {
		c.JSON(400, gin.H{"error": "age 必须是数字"})
		return
	}
	// 3. 范围校验
	if age < 0 || age > 150 {
		c.JSON(400, gin.H{"error": "age 范围非法"})
		return
	}
	// 4. 邮箱格式校验
	// ... 还要自己写正则 ...

	c.JSON(200, gin.H{
		"username": username,
		"email":    email,
		"age":      age,
	})
})

痛点

字段多时繁琐：每个字段都要 c.PostForm 一次，再写一遍非空判断。
类型转换重复：表单传上来的都是字符串，数字、布尔值都要手动转。
校验逻辑散落：必填、范围、格式校验全靠手写，容易遗漏、不一致。
错误信息不统一：每个接口的报错格式可能都不一样。
JSON 请求体难处理：c.PostForm 无法读取 application/json 的请求体。

参数绑定的解决思路

参数绑定把上面这些问题统一交给框架和校验库处理：

定义一个结构体，字段对应请求参数。
用结构体标签声明参数来源（json / form / uri / query）和校验规则（binding）。
调用一次绑定方法，框架自动把请求参数填充到结构体，并执行校验。
校验失败直接返回 400，校验通过即可放心使用强类型字段。

代码会从「一堆 c.PostForm」变成「一个结构体 + 一行绑定」，可读性和可维护性大幅提升。

二、Model 绑定基础：ShouldBind 与 MustBind (Bind) 的区别

Gin 提供了两类绑定方法：

方法	行为	推荐
`ShouldBind` / `ShouldBindJSON` / `ShouldBindQuery` / `ShouldBindUri` 等	绑定失败时只返回 error，由开发者决定如何响应	✅ 推荐
`Bind` / `BindJSON` / `BindQuery` 等	绑定失败时自动设置 400 响应并中止	❌ 不推荐

为什么推荐 ShouldBind

Bind 系列在绑定失败时会自动调用 c.AbortWithStatus(400)，并把状态码硬编码为 400。这看似省事，但：

你无法自定义错误响应格式（比如想统一返回 {"code": 10001, "msg": "..."}）。
在中间件链中，已经写入响应会导致后续逻辑混乱。
灵活性差，难以适配不同业务场景。

ShouldBind 系列把「如何响应错误」的决定权交还给你，更可控。官方文档也推荐使用 ShouldBind 系列。

基础用法对比

package main

import (
	"net/http"

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

// LoginReq 登录请求结构体
type LoginReq struct {
	Username string `json:"username" form:"username" binding:"required"`
	Password string `json:"password" form:"password" binding:"required"`
}

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

	// 推荐写法：ShouldBind + 自定义错误响应
	r.POST("/login", func(c *gin.Context) {
		var req LoginReq
		if err := c.ShouldBind(&req); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{
				"code": 10001,
				"msg":  "参数错误: " + err.Error(),
			})
			return
		}
		c.JSON(http.StatusOK, gin.H{
			"username": req.Username,
		})
	})

	r.Run(":8080")
}

注意 c.ShouldBind(&req) 这一行：它会根据请求的 Content-Type 自动选择用 JSON 还是 Form 来解析。如果客户端发的是 application/json，就走 JSON 绑定；如果是 application/x-www-form-urlencoded，就走 Form 绑定。这正是结构体上同时写 json 和 form 标签的意义。

三、JSON 绑定：绑定 JSON 请求体到结构体

当前后端分离成为主流，JSON 是最常用的请求格式。

客户端请求示例

http

POST /users HTTP/1.1
Content-Type: application/json

{
    "username": "alice",
    "email": "alice@example.com",
    "age": 25
}

Gin 处理代码

package main

import (
	"net/http"

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

type CreateUserReq struct {
	Username string `json:"username" binding:"required"`
	Email    string `json:"email" binding:"required,email"`
	Age      int    `json:"age" binding:"required,gte=0,lte=150"`
}

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

	r.POST("/users", func(c *gin.Context) {
		var req CreateUserReq
		// ShouldBindJSON 专门绑定 JSON 请求体
		if err := c.ShouldBindJSON(&req); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		c.JSON(http.StatusCreated, gin.H{
			"username": req.Username,
			"email":    req.Email,
			"age":      req.Age,
		})
	})

	r.Run(":8080")
}

测试：

bash

curl -X POST http://localhost:8080/users \
  -H "Content-Type: application/json" \
  -d '{"username":"alice","email":"alice@example.com","age":25}'

JSON 绑定的几个注意点

字段名匹配按 json 标签，没有标签则用字段名本身（首字母大写）。
未提供的字段会取零值（int 是 0，string 是 ""），如果该字段标了 required，零值会被判为缺失（注意 int 的 0 也会被判缺失，后面会讲怎么处理）。
多余的字段会被忽略（除非结构体字段是 map 或 json.RawMessage）。

四、Form 绑定：绑定表单数据

传统表单提交或简单的 POST 请求常用 application/x-www-form-urlencoded。

package main

import (
	"net/http"

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

type LoginReq struct {
	Username string `form:"username" binding:"required"`
	Password string `form:"password" binding:"required"`
	Remember bool   `form:"remember"`
}

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

	r.POST("/login", func(c *gin.Context) {
		var req LoginReq
		// ShouldBind 根据 Content-Type 自动选 Form 绑定
		if err := c.ShouldBind(&req); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		c.JSON(http.StatusOK, gin.H{
			"username": req.Username,
			"remember": req.Remember,
		})
	})

	r.Run(":8080")
}

测试：

bash

curl -X POST http://localhost:8080/login \
  -d "username=admin&password=123456&remember=true"
# {"remember":true,"username":"admin"}

注意 Remember bool 字段：表单里的 "true" / "1" / "on" 会被自动转为 true。

五、Query 绑定：绑定查询参数

GET 请求通常把参数放在 URL query string。可以用 ShouldBindQuery 把它们绑定到结构体。

package main

import (
	"net/http"

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

type PageQuery struct {
	Page int    `form:"page" binding:"required,gte=1"`
	Size int    `form:"size" binding:"required,gte=1,lte=100"`
	Sort string `form:"sort"` // 可选
}

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

	r.GET("/users", func(c *gin.Context) {
		var q PageQuery
		if err := c.ShouldBindQuery(&q); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		c.JSON(http.StatusOK, gin.H{
			"page": q.Page,
			"size": q.Size,
			"sort": q.Sort,
		})
	})

	r.Run(":8080")
}

测试：

bash

curl "http://localhost:8080/users?page=1&size=20&sort=desc"
# {"page":1,"size":20,"sort":"desc"}

注意：查询参数都是字符串，但 ShouldBindQuery 会自动转成结构体字段的类型（int、bool 等）。如果传了非数字字符串给 int 字段，会绑定失败。

六、URI 绑定：绑定路由参数

路由参数（:id 这种）也可以绑定到结构体，用 ShouldBindUri。

package main

import (
	"net/http"

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

type UserURI struct {
	ID       int    `uri:"id" binding:"required"`
	Category string `uri:"category" binding:"required"`
}

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

	r.GET("/users/:category/:id", func(c *gin.Context) {
		var u UserURI
		if err := c.ShouldBindUri(&u); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		c.JSON(http.StatusOK, gin.H{
			"id":       u.ID,
			"category": u.Category,
		})
	})

	r.Run(":8080")
}

测试：

bash

curl http://localhost:8080/users/vip/42
# {"category":"vip","id":42}

URI 绑定的好处是把路径参数也纳入结构体管理，校验、类型转换一次完成，不用再 c.Param + strconv.Atoi。

七、绑定标签详解：json、form、uri、binding

结构体标签是绑定机制的核心，下面分别说明。

json 标签

控制 JSON 序列化/反序列化的字段名。

type User struct {
	Username string `json:"username"`     // JSON 字段名为 username
	Email    string `json:"email,omitempty"` // omitempty: 为空时序列化时省略
	Password string `json:"-"`             // - : 永不序列化（隐藏敏感字段）
}

form 标签

控制 Form / Query 参数的字段名（ShouldBind 和 ShouldBindQuery 都读 form 标签）。

type User struct {
	Username string `form:"username"`
	Age      int    `form:"age"`
}

uri 标签

控制路由参数的字段名（仅 ShouldBindUri 读取）。

type User struct {
	ID int `uri:"id"`
}

binding 标签

声明校验规则，由 go-playground/validator 库实现。可以写多个规则，逗号分隔。

type User struct {
	Username string `binding:"required,min=3,max=20"`
	Age      int    `binding:"gte=0,lte=150"`
	Email    string `binding:"required,email"`
}

标签组合写法

一个字段可以同时声明多种来源标签，让同一个结构体适配多种请求格式：

type LoginReq struct {
	Username string `json:"username" form:"username" uri:"username" binding:"required"`
	Password string `json:"password" form:"password" uri:"password" binding:"required"`
}

这样无论请求来自 JSON、Form 还是 URI，都能用同一结构体绑定。

八、参数验证：binding 标签验证规则

Gin 内置 go-playground/validator/v10，提供丰富的校验规则。下面列举常用规则。

字符串类规则

规则	含义	示例
`required`	必填（非零值）	`binding:"required"`
`min` / `max`	最小/最大长度（字符串）或数值	`min=3,max=20`
`len`	固定长度	`len=11`（手机号 11 位）
`oneof`	枚举值之一	`oneof=male female`
`email`	邮箱格式	`email`
`url`	URL 格式	`url`
`contains`	包含子串	`contains=gin`
`startswith`	以指定前缀开头	`startswith=http`
`endswith`	以指定后缀结尾	`endswith=.com`
`excludes`	不包含子串	`excludes=admin`

数值类规则

规则	含义	示例
`gt` / `gte`	大于 / 大于等于	`gte=18`
`lt` / `lte`	小于 / 小于等于	`lte=150`
`eq` / `ne`	等于 / 不等于	`eq=10`

其他常用规则

规则	含义
`datetime=2006-01-02`	日期时间格式（Go 风格 layout）
`ip` / `ipv4` / `ipv6`	IP 格式
`uuid` / `uuid5`	UUID 格式
`unique`	切片/数组元素唯一
`dive`	进入切片/ map 元素做校验

一个综合验证示例

package main

import (
	"net/http"

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

type RegisterReq struct {
	Username string `json:"username" binding:"required,min=3,max=20"`
	Password string `json:"password" binding:"required,min=6,max=20"`
	Email    string `json:"email" binding:"required,email"`
	Age      int    `json:"age" binding:"required,gte=1,lte=150"`
	Gender   string `json:"gender" binding:"required,oneof=male female other"`
	Phone    string `json:"phone" binding:"required,len=11"`
	Website  string `json:"website" binding:"omitempty,url"`
}

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

	r.POST("/register", func(c *gin.Context) {
		var req RegisterReq
		if err := c.ShouldBindJSON(&req); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		c.JSON(http.StatusOK, gin.H{
			"username": req.Username,
			"email":    req.Email,
		})
	})

	r.Run(":8080")
}

测试一个合法请求：

bash

curl -X POST http://localhost:8080/register \
  -H "Content-Type: application/json" \
  -d '{
    "username":"alice",
    "password":"secret123",
    "email":"alice@example.com",
    "age":25,
    "gender":"female",
    "phone":"13800138000",
    "website":"https://alice.example.com"
  }'

测试一个非法请求（年龄超范围）：

bash

curl -X POST http://localhost:8080/register \
  -H "Content-Type: application/json" \
  -d '{
    "username":"bob",
    "password":"secret123",
    "email":"bob@example.com",
    "age":200,
    "gender":"male",
    "phone":"13800138000"
  }'
# 返回 400，错误信息会指出 age 不满足 lte=150

关于 `required` 与零值

required 判断的是「非零值」，这带来一个陷阱：对于 int 类型，0 是零值，会被判为「缺失」。如果你希望允许 age=0，要么不写 required，要么改用指针类型 *int。

type Req struct {
	// 0 会被判缺失
	Age1 int `json:"age1" binding:"required,gte=0"`
	// 用指针，nil 才算缺失，0 可以传
	Age2 *int `json:"age2" binding:"required,gte=0"`
}

九、自定义错误信息

validator 默认返回的错误信息是英文且偏技术化，例如 Key: 'RegisterReq.Age' Error:Field validation for 'Age' failed on the 'lte' tag。生产环境通常需要更友好的中文错误信息。

方式 1：手动解析错误并映射

package main

import (
	"errors"
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
)

type RegisterReq struct {
	Username string `json:"username" binding:"required,min=3,max=20"`
	Email    string `json:"email" binding:"required,email"`
	Age      int    `json:"age" binding:"gte=1,lte=150"`
}

// 字段错误信息映射
var fieldMsg = map[string]string{
	"Username": "用户名不能为空且长度需在 3-20 之间",
	"Email":    "邮箱格式不正确",
	"Age":      "年龄需在 1-150 之间",
}

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

	r.POST("/register", func(c *gin.Context) {
		var req RegisterReq
		if err := c.ShouldBindJSON(&req); err != nil {
			var valErrs validator.ValidationErrors
			if errors.As(err, &valErrs) {
				for _, fe := range valErrs {
					if msg, ok := fieldMsg[fe.Field()]; ok {
						c.JSON(http.StatusBadRequest, gin.H{"error": msg})
						return
					}
				}
			}
			c.JSON(http.StatusBadRequest, gin.H{"error": "参数错误"})
			return
		}
		c.JSON(http.StatusOK, gin.H{"username": req.Username})
	})

	r.Run(":8080")
}

测试：

bash

curl -X POST http://localhost:8080/register \
  -H "Content-Type: application/json" \
  -d '{"username":"a","email":"bad","age":200}'
# {"error":"用户名不能为空且长度需在 3-20 之间"}

方式 2：注册自定义翻译器（validator 自带 zh 本地化）

通过 validator 的 translations/zh 包注册中文翻译器，可以让错误信息自动中文化。这种写法稍复杂，但在大型项目里更通用。初学者可以先用方式 1，等熟悉后再引入翻译器。

十、多格式绑定示例：同时支持 JSON 和 Form

有时同一个接口希望既能接收 JSON 又能接收表单。借助 ShouldBind（自动按 Content-Type 切换）+ 同时声明 json 和 form 标签即可。

package main

import (
	"net/http"

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

type LoginReq struct {
	Username string `json:"username" form:"username" binding:"required"`
	Password string `json:"password" form:"password" binding:"required"`
}

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

	r.POST("/login", func(c *gin.Context) {
		var req LoginReq
		// ShouldBind 会根据 Content-Type 自动选择
		if err := c.ShouldBind(&req); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		c.JSON(http.StatusOK, gin.H{"username": req.Username})
	})

	r.Run(":8080")
}

两种方式都能成功：

bash

# JSON 方式
curl -X POST http://localhost:8080/login \
  -H "Content-Type: application/json" \
  -d '{"username":"admin","password":"123456"}'

# Form 方式
curl -X POST http://localhost:8080/login \
  -d "username=admin&password=123456"

十一、ShouldBindJSON、ShouldBindQuery、ShouldBindUri 专用方法

方法	数据来源	读取的标签
`ShouldBindJSON`	请求体 JSON	`json`
`ShouldBind`	自动按 Content-Type	`json` 或 `form`
`ShouldBindQuery`	URL 查询参数	`form`
`ShouldBindUri`	路由参数	`uri`
`ShouldBindXML` / `ShouldBindYAML`	请求体 XML/YAML	`xml` / `yaml`
`ShouldBindHeader`	请求头	`header`

package main

import (
	"net/http"

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

type AuthHeader struct {
	Token string `header:"X-Token" binding:"required"`
	AppID string `header:"X-App-Id" binding:"required"`
}

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

	r.GET("/secure", func(c *gin.Context) {
		var h AuthHeader
		if err := c.ShouldBindHeader(&h); err != nil {
			c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
			return
		}
		c.JSON(http.StatusOK, gin.H{"token": h.Token, "app_id": h.AppID})
	})

	r.Run(":8080")
}

测试：

bash

curl -H "X-Token: abc123" -H "X-App-Id: demo" http://localhost:8080/secure
# {"app_id":"demo","token":"abc123"}

十二、实战示例：用户注册 API（完整参数验证）

把前面学到的内容综合起来，写一个贴近真实业务的用户注册接口。

需求

请求体为 JSON。
字段：用户名、密码、邮箱、手机号、性别、年龄、是否同意协议、可选的推荐人用户名。
校验规则：
- 用户名：必填，3-20 字符，仅字母数字下划线。
- 密码：必填，6-20 字符。
- 邮箱：必填，合法邮箱。
- 手机号：必填，11 位数字。
- 性别：必填，male/female/other 之一。
- 年龄：必填，1-150。
- 是否同意协议：必填，必须为 true。
- 推荐人：可选。

完整代码

package main

import (
	"errors"
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
)

// RegisterReq 用户注册请求
type RegisterReq struct {
	Username string `json:"username" binding:"required,min=3,max=20,alphanum"`
	Password string `json:"password" binding:"required,min=6,max=20"`
	Email    string `json:"email" binding:"required,email"`
	Phone    string `json:"phone" binding:"required,numeric,len=11"`
	Gender   string `json:"gender" binding:"required,oneof=male female other"`
	Age      int    `json:"age" binding:"required,gte=1,lte=150"`
	Agreed   bool   `json:"agreed" binding:"required,eq=true"`
	Referrer string `json:"referrer" binding:"omitempty,alphanum,min=3,max=20"`
}

// 字段中文错误信息
var errMsg = map[string]string{
	"Username": "用户名必填，3-20 位字母数字下划线",
	"Password": "密码必填，6-20 位",
	"Email":    "邮箱格式不正确",
	"Phone":    "手机号必须为 11 位数字",
	"Gender":   "性别只能是 male/female/other",
	"Age":      "年龄需在 1-150 之间",
	"Agreed":   "必须同意用户协议",
	"Referrer": "推荐人用户名格式不正确",
}

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

	r.POST("/api/v1/register", func(c *gin.Context) {
		var req RegisterReq
		if err := c.ShouldBindJSON(&req); err != nil {
			// 解析校验错误
			var valErrs validator.ValidationErrors
			if errors.As(err, &valErrs) {
				for _, fe := range valErrs {
					if msg, ok := errMsg[fe.Field()]; ok {
						c.JSON(http.StatusBadRequest, gin.H{
							"code": 10001,
							"msg":  msg,
							"field": fe.Field(),
						})
						return
					}
				}
			}
			// JSON 格式错误等
			c.JSON(http.StatusBadRequest, gin.H{
				"code": 10002,
				"msg":  "请求格式错误: " + err.Error(),
			})
			return
		}

		// ===== 业务逻辑（此处省略入库） =====
		// 在真实项目中，这里会调用 service 层写入数据库
		// 同时还要做用户名是否已存在等业务校验

		c.JSON(http.StatusOK, gin.H{
			"code": 0,
			"msg":  "注册成功",
			"data": gin.H{
				"username": req.Username,
				"email":    req.Email,
				"phone":    req.Phone,
				"gender":   req.Gender,
				"age":      req.Age,
			},
		})
	})

	r.Run(":8080")
}

测试合法请求

bash

curl -X POST http://localhost:8080/api/v1/register \
  -H "Content-Type: application/json" \
  -d '{
    "username":"alice2024",
    "password":"secret123",
    "email":"alice@example.com",
    "phone":"13800138000",
    "gender":"female",
    "age":25,
    "agreed":true
  }'

json

{
    "code": 0,
    "msg": "注册成功",
    "data": {
        "age": 25,
        "email": "alice@example.com",
        "gender": "female",
        "phone": "13800138000",
        "username": "alice2024"
    }
}

测试多种非法请求

bash

# 1. 用户名太短
curl -X POST http://localhost:8080/api/v1/register \
  -H "Content-Type: application/json" \
  -d '{"username":"a","password":"secret123","email":"a@b.com","phone":"13800138000","gender":"female","age":25,"agreed":true}'
# {"code":10001,"field":"Username","msg":"用户名必填，3-20 位字母数字下划线"}

# 2. 邮箱格式错误
curl -X POST http://localhost:8080/api/v1/register \
  -H "Content-Type: application/json" \
  -d '{"username":"alice","password":"secret123","email":"bad-email","phone":"13800138000","gender":"female","age":25,"agreed":true}'
# {"code":10001,"field":"Email","msg":"邮箱格式不正确"}

# 3. 没同意协议
curl -X POST http://localhost:8080/api/v1/register \
  -H "Content-Type: application/json" \
  -d '{"username":"alice","password":"secret123","email":"a@b.com","phone":"13800138000","gender":"female","age":25,"agreed":false}'
# {"code":10001,"field":"Agreed","msg":"必须同意用户协议"}

# 4. 手机号不是数字
curl -X POST http://localhost:8080/api/v1/register \
  -H "Content-Type: application/json" \
  -d '{"username":"alice","password":"secret123","email":"a@b.com","phone":"abc12345678","gender":"female","age":25,"agreed":true}'
# {"code":10001,"field":"Phone","msg":"手机号必须为 11 位数字"}

可以看到，校验规则覆盖了格式、长度、范围、枚举、必填，错误信息也做到了中文化和字段级定位，非常贴近真实项目。

十三、小结

本篇把「参数处理」从手写升级为工程化，是 Gin 实战中最重要的一课：

绑定的价值：用结构体 + 标签替代散落的 c.Query / c.PostForm，统一校验、统一错误处理、强类型安全。
ShouldBind vs Bind：始终优先用 ShouldBind 系列，保留对响应的完全控制权。
四种来源绑定：JSON（ShouldBindJSON）、Form（ShouldBind）、Query（ShouldBindQuery）、URI（ShouldBindUri），以及 Header 绑定。
标签体系：json / form / uri / header 控制字段名映射，binding 控制校验规则，可灵活组合。
校验规则：required / min / max / len / oneof / email / url / gte / lte / numeric / alphanum 等覆盖了 90% 场景。
零值陷阱：required 对 int 的 0 会判缺失，可用指针类型规避。
自定义错误信息：通过 validator.ValidationErrors 解析字段名，映射中文文案，提升用户体验。
实战：用户注册 API 串联了多种校验规则，可作为项目模板复用。

下一篇我们将学习响应处理（JSON / XML / 文件 / Cookie）与路由分组，把「请求进来」和「响应出去」两侧的能力补齐，并完成一个 RESTful API 的完整示例。

上一篇：02-第一个Gin程序与路由基础下一篇：04-响应处理与路由分组

请求处理：参数绑定与验证 ​

一、为什么要用参数绑定 ​

痛点 ​

参数绑定的解决思路 ​

二、Model 绑定基础：ShouldBind 与 MustBind (Bind) 的区别 ​

为什么推荐 ShouldBind ​

基础用法对比 ​

三、JSON 绑定：绑定 JSON 请求体到结构体 ​

客户端请求示例 ​

Gin 处理代码 ​

JSON 绑定的几个注意点 ​

四、Form 绑定：绑定表单数据 ​

五、Query 绑定：绑定查询参数 ​

六、URI 绑定：绑定路由参数 ​

七、绑定标签详解：json、form、uri、binding ​

json 标签 ​

form 标签 ​

uri 标签 ​

binding 标签 ​

标签组合写法 ​

八、参数验证：binding 标签验证规则 ​

字符串类规则 ​

数值类规则 ​

其他常用规则 ​

一个综合验证示例 ​

关于 required 与零值 ​

九、自定义错误信息 ​

方式 1：手动解析错误并映射 ​

方式 2：注册自定义翻译器（validator 自带 zh 本地化） ​

十、多格式绑定示例：同时支持 JSON 和 Form ​

十一、ShouldBindJSON、ShouldBindQuery、ShouldBindUri 专用方法 ​

Header 绑定示例 ​

十二、实战示例：用户注册 API（完整参数验证） ​

需求 ​

完整代码 ​

测试合法请求 ​

测试多种非法请求 ​

十三、小结 ​

请求处理：参数绑定与验证

一、为什么要用参数绑定

痛点

参数绑定的解决思路

二、Model 绑定基础：ShouldBind 与 MustBind (Bind) 的区别

为什么推荐 ShouldBind

基础用法对比

三、JSON 绑定：绑定 JSON 请求体到结构体

客户端请求示例

Gin 处理代码

JSON 绑定的几个注意点

四、Form 绑定：绑定表单数据

五、Query 绑定：绑定查询参数

六、URI 绑定：绑定路由参数

七、绑定标签详解：json、form、uri、binding

json 标签

form 标签

uri 标签

binding 标签

标签组合写法

八、参数验证：binding 标签验证规则

字符串类规则

数值类规则

其他常用规则

一个综合验证示例

关于 `required` 与零值

九、自定义错误信息

方式 1：手动解析错误并映射

方式 2：注册自定义翻译器（validator 自带 zh 本地化）

十、多格式绑定示例：同时支持 JSON 和 Form

十一、ShouldBindJSON、ShouldBindQuery、ShouldBindUri 专用方法

Header 绑定示例

十二、实战示例：用户注册 API（完整参数验证）

需求

完整代码

测试合法请求

测试多种非法请求

十三、小结