在做API部分开发时，需要对请求参数的校验，防止用户的恶意请求。
例如日期格式，用户年龄，性别等必须是正常的值，不能随意设置。
我们使用github.com/go-playground/validator进行参数校验
只需要在定义结构体时使用binding或validatetag标识相关校验规则

1 安装与使用

go get github.com/go-playground/validator/v10

  1. package main
  3. import (
  4.     "fmt"
  6.     "github.com/go-playground/validator/v10"
  7. )
  9. type User struct {
  10.     Username string `validate:"min=6,max=10"`
  11.     Age      uint8  `validate:"gte=1,lte=10"`
  12.     Sex      string `validate:"oneof=female male"`
  13. }
  15. func main() {
  16.     validate := validator.New()
  18.     user1 := User{Username: "aaa", Age: 11, Sex: "null"}
  19.     err := validate.Struct(user1)
  20.     if err != nil {
  21.         fmt.Println(err)
  22.     }
  24.     user2 := User{Username: "bbb", Age: 8, Sex: "male"}
  25.     err = validate.Struct(user2)
  26.     if err != nil {
  27.         fmt.Println(err)
  28.     }
  30. }

我们在结构体定义validator标签的tag，使用validator.New()创建一个验证器，这个验证器可以指定选项、添加自定义约束，然后在调用他的Struct()方法来验证各种结构对象的字段是否符合定义的约束。

上面的例子，我们在User结构体中，有三个字段：

  • Name：通过min和max来进行约束，Name的字符串长度为[6,10]之间。
  • Age：通过gte和lte对年轻的范围进行约束，age的大小大于1，小于10。
  • Sex：通过oneof对值进行约束，只能是所列举的值

所以user1会进行报错，错误信息如下：

Key: ‘User.Name’ Error:Field validation for ‘Name’ failed on the ‘min’ tag Key: ‘User.Age’ Error:Field validation for ‘Age’ failed on the ‘lte’ tag Key: ‘User.Sex’ Error:Field validation for ‘Sex’ failed on the ‘oneof’ tag

2 约束

(1) 字符串

excludesall：不包含参数中任意的 UNICODE 字符，例如excludesall=ab；
excludesrune：不包含参数表示的 rune 字符，excludesrune=asong；
startswith：以参数子串为前缀，例如startswith=hi；
endswith：以参数子串为后缀，例如endswith=bye。
contains=：包含参数子串，例如contains=email；
containsany：包含参数中任意的 UNICODE 字符，例如containsany=ab；
containsrune：包含参数表示的 rune 字符，例如`containsrune=asong；
excludes：不包含参数子串，例如excludes=email；

(2) 范围

范围约束的字段类型分为三种：

  • 对于数值，我们则可以约束其值
  • 对于切片、数组和map，我们则可以约束其长度
  • 对于字符串，我们则可以约束其长度

ne：不等于参数值，例如ne=5；
gt：大于参数值，例如gt=5；
gte：大于等于参数值，例如gte=50；
lt：小于参数值，例如lt=50；
lte：小于等于参数值，例如lte=50；
oneof：只能是列举出的值其中一个，这些值必须是数值或字符串，以空格分隔，如果字符串中有空格，将字符串用单引号包围，例如oneof=male female。
eq：等于参数值，注意与len不同。对于字符串，eq约束字符串本身的值，而len约束字符串长度。例如eq=10；
len：等于参数值，例如len=10；
max：小于等于参数值，例如max=10；
min：大于等于参数值，例如min=10

(3) 字段间

eqfield：定义字段间的相等约束，用于约束同一结构体中的字段。例如：eqfield=Password
eqcsfield：约束统一结构体中字段等于另一个字段（相对），确认密码时可以使用，例如：eqfiel=ConfirmPassword
nefield：用来约束两个字段是否相同，确认两种颜色是否一致时可以使用，例如：nefield=Color1
necsfield：约束两个字段是否相同（相对）

(4) 其它常用

unique：指定唯一性约束，不同类型处理不同：

  • 对于map，unique约束没有重复的值
  • 对于数组和切片，unique没有重复的值
  • 对于元素类型为结构体的碎片，unique约束结构体对象的某个字段不重复，使用unique=field指定字段名

email：使用email来限制字段必须是邮件形式，直接写eamil即可，无需加任何指定。
omitempty：字段未设置，则忽略
-：跳过该字段，不检验；
|：使用多个约束，只需要满足其中一个，例如rgb|rgba；
required：字段必须设置，不能为默认值；

3 自定义结构体校验

  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6.     "time"
  8.     "github.com/gin-gonic/gin"
  9.     "github.com/gin-gonic/gin/binding"
  10.     "github.com/go-playground/validator/v10"
  11. )
  13. type Info struct {
  14.     CreateTime time.Time `form:"create_time" binding:"required,timing" time_format:"2006-01-02"`
  15.     UpdateTime time.Time `form:"update_time" binding:"required,timing" time_format:"2006-01-02"`
  16. }
  18. // 自定义验证规则断言
  19. func timing(fl validator.FieldLevel) bool {
  20.     if date, ok := fl.Field().Interface().(time.Time); ok {
  21.         today := time.Now()
  22.         if today.After(date) {
  23.             return false
  24.         }
  25.     }
  26.     return true
  27. }
  29. func main() {
  30.     route := gin.Default()
  31.     // 注册验证
  32.     if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
  33.         err := v.RegisterValidation("timing", timing)
  34.         if err != nil {
  35.             fmt.Println("success")
  36.         }
  37.     }
  39.     route.GET("/time", func(c *gin.Context) {
  40.         var b Info
  41.         // 数据模型绑定查询字符串验证
  42.         if err := c.ShouldBindWith(&b, binding.Query); err == nil {
  43.             c.JSON(http.StatusOK, gin.H{"message": "time are valid!"})
  44.         } else {
  45.             c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
  46.         }
  47.     })
  48.     route.Run(":8080")
  49. }

4 错误信息翻译

validator默认返回错误时都是英文的，validator库本身是支持国际化的，借助相应的语言包可以实现校验错误提示信息的自动翻译。

  1. package main
  3. import (
  4.     "fmt"
  5.     "log"
  6.     "net/http"
  8.     "github.com/gin-gonic/gin"
  9.     "github.com/gin-gonic/gin/binding"
  10.     "github.com/go-playground/locales/en"
  11.     "github.com/go-playground/locales/zh"
  12.     ut "github.com/go-playground/universal-translator"
  13.     "github.com/go-playground/validator/v10"
  14.     enTranslations "github.com/go-playground/validator/v10/translations/en"
  15.     chTranslations "github.com/go-playground/validator/v10/translations/zh"
  16. )
  18. var trans ut.Translator
  20. // local 通常取决于 http 请求头的 'Accept-Language'
  21. func transInit(local string) (err error) {
  22.     if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
  23.         zhT := zh.New() //chinese
  24.         enT := en.New() //english
  25.         uni := ut.New(enT, zhT, enT)
  27.         var o bool
  28.         trans, o = uni.GetTranslator(local)
  29.         if !o {
  30.             return fmt.Errorf("uni.GetTranslator(%s) failed", local)
  31.         }
  32.         //register translate
  33.         // 注册翻译器
  34.         switch local {
  35.         case "en":
  36.             err = enTranslations.RegisterDefaultTranslations(v, trans)
  37.         case "zh":
  38.             err = chTranslations.RegisterDefaultTranslations(v, trans)
  39.         default:
  40.             err = enTranslations.RegisterDefaultTranslations(v, trans)
  41.         }
  42.         return
  43.     }
  44.     return
  45. }
  47. type loginRequest struct {
  48.     Username string `json:"username" binding:"required"`
  49.     Password string `json:"password" binding:"required,max=16,min=6"`
  50. }
  52. func main() {
  53.     if err := transInit("zh"); err != nil {
  54.         fmt.Printf("init trans failed, err:%v\n", err)
  55.         return
  56.     }
  57.     router := gin.Default()
  59.     router.POST("/user/login", login)
  61.     err := router.Run(":8888")
  62.     if err != nil {
  63.         log.Println("failed")
  64.     }
  65. }
  67. func login(c *gin.Context) {
  68.     var req loginRequest
  69.     if err := c.ShouldBindJSON(&req); err != nil {
  70.         // 获取validator.ValidationErrors类型的errors
  71.         errs, ok := err.(validator.ValidationErrors)
  72.         if !ok {
  73.             // 非validator.ValidationErrors类型错误直接返回
  74.             c.JSON(http.StatusOK, gin.H{
  75.                 "msg": err.Error(),
  76.             })
  77.             return
  78.         }
  79.         // validator.ValidationErrors类型错误则进行翻译
  80.         c.JSON(http.StatusOK, gin.H{
  81.             "msg": errs.Translate(trans),
  82.         })
  83.         return
  84.     }
  85.     //login 操作省略
  86.     c.JSON(http.StatusOK, gin.H{
  87.         "code": 0,
  88.         "msg":  "success",
  89.     })
  90. }