Golang中web参数校验的实现

type Login struct {
	User     string `json:"user" binding:"required"`
	Password string `json:"password" binding:"required"`
}

func loginHandler(c *gin.Context) {
	var login Login

	// 尝试将请求的 JSON body 绑定到 login 结构体上
	// 在绑定的同时，Gin 会根据 "binding" 标签进行校验
	err := c.ShouldBindJSON(&login)
	if err != nil {
		// 如果 err 不是 nil，说明校验失败了！
		// 比如，某个 "required" 的字段没有被提供。
		// Gin 通常会自动返回一个 400 Bad Request 错误。
		c.JSON(400, gin.H{"error": err.Error()})
		return
	}

	// 如果 err 是 nil，说明所有校验都通过了！
	c.JSON(200, gin.H{"status": "you are logged in"})
}

type SearchQuery struct {
	Keyword string `form:"keyword" binding:"required"`
	Page    int    `form:"page"    binding:"required,gt=0"`
}

func searchHandler(c *gin.Context) {
    var query SearchQuery

    // 从 URL query 中绑定并校验参数
    // 注意这里换成了 ShouldBindQuery
    err := c.ShouldBindQuery(&query)

    if err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }

    // 校验通过！
    c.JSON(200, gin.H{
        "message": "search parameters are valid",
        "keyword": query.Keyword,
        "page":    query.Page,
    })
}

type RegisterUser struct {
	// 用户名：必填，长度在 4 到 20 个字符之间
	Username string `json:"username" binding:"required,min=4,max=20"`

	// 邮箱：必填，且必须是合法的邮箱格式
	Email string `json:"email" binding:"required,email"`

	// 年龄：选填，但如果提供了，必须大于等于 18 岁，小于等于 100 岁
	Age int `json:"age" binding:"gte=18,lte=100"`

	// 用户类型：必填，并且值必须是 'user' 或 'admin' 中的一个
	UserType string `json:"user_type" binding:"required,oneof=user admin"`
}

func registerUserHandler(c *gin.Context) {
	var register RegisterUser
	err := c.ShouldBindJSON(&register)
	if err != nil {
		c.JSON(400, gin.H{"error": err.Error()})
		return
	}

	c.JSON(200, gin.H{
		"username": register.Username,
		"email":    register.Email,
	})
}

func registerUserHandler(c *gin.Context) {
	var register RegisterUser
	err := c.ShouldBindJSON(&register)
	if err != nil {
		var verrs validator.ValidationErrors
		ok := errors.As(err, &verrs)
		if !ok {
			// 如果不是 ValidationErrors 类型的错误，直接返回原始错误
			c.JSON(400, gin.H{"error": err.Error()})
			return
		}
		// 创建一个 map 来存放我们“翻译”后的错误信息
		// key 是字段名，value 是错误信息
		// 比如：{"Username": "长度不能小于 4 个字符"}
		translatedErrors := make(map[string]string)
		for _, fe := range verrs {
			// fe.Field() 获取出错的字段名，比如 "Username"
			translatedErrors[fe.Field()] = getErrorMsg(fe)
		}

		c.JSON(400, gin.H{"errors": translatedErrors})
		return
	}

	c.JSON(200, gin.H{
		"username": register.Username,
		"email":    register.Email,
	})
}

// 这个函数专门用来“翻译”错误信息
func getErrorMsg(fe validator.FieldError) string {
	// fe.Tag() 能获取到是哪个校验规则出错了，比如 "required", "min", "email"
	switch fe.Tag() {
	case "required":
		return "这是必填项"
	case "min":
		// fe.Param() 能获取到规则后面的参数，比如 "min=4" 中的 "4"
		return "长度不能小于 " + fe.Param() + " 个字符"
	case "max":
		return "长度不能超过 " + fe.Param() + " 个字符"
	case "email":
		return "请输入正确的邮箱地址"
	case "oneof":
		return "必须是 " + fe.Param() + " 中的一个"
	default:
		return "未知错误"
	}
}

// isPasswordStrong 就是我们的自定义校验函数
func isPasswordStrong(fl validator.FieldLevel) bool {
    // fl.Field().String() 可以获取到字段的字符串值
    password := fl.Field().String()
    
    hasLetter := false
    hasDigit := false

    // 遍历密码字符串，检查是否同时包含字母和数字
    for _, char := range password {
        if unicode.IsLetter(char) {
            hasLetter = true
        }
        if unicode.IsDigit(char) {
            hasDigit = true
        }
    }
    
    return hasLetter && hasDigit
}

// 从 Gin 的 binding 中获取底层的 validator 引擎
	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
		// 注册我们的自定义校验函数
		// 第一个参数是这个规则在 struct tag 中使用的名字
		// 第二个参数是我们的函数
		v.RegisterValidation("strong_password", isPasswordStrong)
	}