^-^
【go工程组件】字段验证器validator
最近更新：2024-12-11   |   字数总计：1.7k   |   阅读估时：9分钟   |   阅读量：次
  1. 字段验证器validator
    1. 标签符号及单字段验证
    2. struct绑定与多层级校验
    3. 自定义字段、结构体补充及自定义验证
      1. 自定义字段
      2. 自定义结构补充验证
      3. 自定义tag验证
    4. struct与map基于map规则验证
      1. 集合验证
      2. 集合作为规则验证struct
    5. 根据locale本地化提示消息

字段验证器validator

  • 作用：字段验证，对外界输入做校验，确保应用程序接收到的输入是预期的输入
  • 应用场景：
    1. 凡是需要对字段进行校验的场景
    2. api输入校验
  • 有什么
    1. 预定义tag，常见的字段类型格式做了预定义
    2. 自定义验证：自定义字段、自定义结构补充验证、自定义tag验证
    3. 消息提示的本地化
  • 安装依赖
    1
    go get github.com/go-playground/validator/v10
  • 验证器初始化，validate.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    package validate

    import (
    	"log"

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

    var validate *validator.Validate

    func init() {
    	validate = validator.New()
    	validate.SetTagName("v")
    }

    func outRes(tag string, err *error) {
    	log.Println("----------------------start " + tag + "-------------------")
    	log.Println(*err)
    	log.Println("----------------------end " + tag + "-------------------")
    	err = nil
    }

标签符号及单字段验证

  • single_field.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    package validate

    import "time"

    // bool
    // number
    // string
    // []
    // set
    // time
    func SingleFieldValidate() {
    	v := validate
    	var err error

    	var b = "true"
    	err = v.Var(b, "boolean")
    	outRes("boolean", &err)

    	var i = "100"
    	err = v.Var(i, "number")
    	outRes("number", &err)

    	var f = "100.123"
    	err = v.Var(f, "numeric")
    	outRes("numeric", &err)

    	var str = "abcdefg"
    	err = v.Var(str, "alpha")
    	outRes("alpha", &err)

    	var slice = []int{
    		1, 2, 3, 4, 5, 6, 7, 8,
    	}
    	err = v.Var(slice, "max=15,min=2") // 长度校验
    	outRes("slice", &err)

    	var mp = make(map[int]int)
    	mp[1] = 1
    	mp[2] = 2
    	mp[3] = 3
    	err = v.Var(slice, "max=15,min=2") // 长度校验
    	outRes("map", &err)

    	var timeStr = time.Now().Format("2006-01-02 15:04:05")
    	err = v.Var(timeStr, "datetime=2006-01-02 15:04:05") // 必须指定验证的时间的格式
    	outRes("time", &err)

    	s1 := "abc"
    	s2 := "bcd"
    	err = v.VarWithValue(s1, s2, "eqfield") // 是否相等?
    	outRes("eqfield", &err)
    }

struct绑定与多层级校验

  • struct.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    package validate

    import (
    	"fmt"
    )

    type User struct { // v来自于validate init的时候给的tag name
    	Name            string            `v:"required,alphaunicode"`
    	Age             uint8             `v:"gte=10,lte=130"`
    	Phone           string            `v:"required,e164"`
    	Email           string            `v:"required,email"`
    	FavouriteColor  string            `v:"hexcolor|rgb|rgba|hsl|hsla"`
    	FavouriteColor2 string            `v:"iscolor"`
    	Address         *Address          `v:"required"`
    	ContactUser     []*ContactUser    `v:"required,gte=1,dive"` // 深入到下一层验证
    	Hobby           []string          `v:"required,gte=2,dive,required,gte=2,alphaunicode"`
    	Data            map[string]string `v:"required,gte=2,dive,keys,alpha,len=2,endkeys,required,gte=2,alphaunicode"`
    }

    type ContactUser struct {
    	Name string `v:"required,alphaunicode"`
    	Age  uint8  `v:"gte=10,lte=130"`
    	// 下面三选一
    	Phone   string   `v:"required_without_all=Email Address,omitempty,e164"`
    	Email   string   `v:"required_without_all=Phone Address,omitempty,email"`
    	Address *Address `v:"required_without_all=Phone Email"`
    }

    type Address struct {
    	Province string `v:"required"`
    	City     string `v:"required"`
    }

    func StructValidate() {
    	addr := &Address{
    		Province: "hunan",
    		City:     "changsha",
    	}
    	contactUser := &ContactUser{
    		Name:  "nn",
    		Age:   14,
    		Phone: "+8613800138000",
    	}
    	user := &User{
    		Name:            "lin",
    		Age:             11,
    		Phone:           "+8613800138000",
    		Email:           "lin@xx.cn",
    		FavouriteColor:  "#ffff",
    		FavouriteColor2: "rgb(255,255,255)",
    		Address:         addr,
    		ContactUser:     []*ContactUser{contactUser},
    		Hobby:           []string{"lanqiu", "yumao"},
    		Data:            map[string]string{"AA": "aa", "BB": "bb"},
    	}
    	err := validate.Struct(user)
    	// outRes("struct", &err)
    	if err != nil {
    		fmt.Println("valid failed-----")
    		fmt.Println(err)
    	}
    }

自定义字段、结构体补充及自定义验证

自定义字段

  • custom_field.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    package validate

    import (
    	"database/sql"
    	"database/sql/driver"
    	"fmt"
    	"reflect"
    )

    type DbBackedUser struct {
    	Name sql.NullString `v:"required"`
    	Age  sql.NullInt64  `v:"required"`
    	Loc  Location       `v:"required"`
    }

    type Location struct {
    	X float64
    	Y float64
    }

    func CustomField() {
    	validate.RegisterCustomTypeFunc(ValidateValuer, sql.NullInt64{}, sql.NullString{}, sql.NullFloat64{})
    	validate.RegisterCustomTypeFunc(ValidateLocation, Location{})

    	x := DbBackedUser{Name: sql.NullString{String: "ni", Valid: true}, Age: sql.NullInt64{Int64: 20, Valid: true}, Loc: Location{X: 1, Y: 1}}
    	err := validate.Struct(x)
    	if err != nil {
    		fmt.Println(err)
    	}
    }

    func ValidateValuer(field reflect.Value) interface{} {
    	if valuer, ok := field.Interface().(driver.Valuer); ok {
    		val, err := valuer.Value()
    		if err == nil {
    			return val
    		} else {
    			return nil
    		}
    	}
    	return nil
    }

    func ValidateLocation(field reflect.Value) interface{} {
    	if valuer, ok := field.Interface().(Location); ok {
    		if valuer.X != 0 && valuer.Y != 0 {
    			return fmt.Sprintf("point(%v,%v)", valuer.X, valuer.Y)
    		}
    	}
    	return nil
    }

自定义结构补充验证

  • struct_lever.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    package validate

    import (
    	"fmt"
    	"reflect"
    	"strings"

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

    type StructLevelUser struct {
    	FirtName string
    	LastName string
    	Age      uint8  `v:"gte=0,lte=130"`
    	Email    string `fld:"e-mail" v:"required,email"` // fld指定别名
    }

    func StructLevelCase() {
    	// 别名验证
    	validate.RegisterTagNameFunc(func(field reflect.StructField) string {
    		name := strings.SplitN(field.Tag.Get("fld"), ",", 2)[0]
    		if name != "-" {
    			return name
    		}
    		return ""
    	})
    	validate.RegisterStructValidation(func(sl validator.StructLevel) {
    		user := sl.Current().Interface().(StructLevelUser)
    		if len(user.LastName) == 0 && len(user.FirtName) == 0 {
    			sl.ReportError(user.FirtName, "fname", "FirstName", "fnamelname", "")
    			sl.ReportError(user.LastName, "lname", "LastName", "fnamelname", "")
    		}
    	}, StructLevelUser{})
    	user := &StructLevelUser{
    		FirtName: "xx",
    		LastName: "yy",
    		Age:      100,
    		Email:    "ni99.cn",
    	}
    	err := validate.Struct(user)
    	if err != nil {
    		if _, ok := err.(*validator.InvalidValidationError); ok {
    			fmt.Println(err)
    		}
    		for _, err := range err.(validator.ValidationErrors) {
    			fmt.Println(err)
    		}
    	}
    }

自定义tag验证

  • custom_validation.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    package validate

    import (
    	"fmt"

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

    type CustomValidateUser struct {
    	Name   string `v:"required,is-lin"`
    	Gender int    `v:"gender"`
    }

    func CustomValidate() {
    	validate.RegisterValidation("is-lin", func(fl validator.FieldLevel) bool {
    		return fl.Field().String() == "lin"
    	})
    	validate.RegisterValidation("gender", func(fl validator.FieldLevel) bool {
    		i := fl.Field().Int()
    		if i != 0 && i != 1 && i != 2 {
    			return false
    		}
    		return true
    	})

    	s := CustomValidateUser{
    		Name:   "lin",
    		Gender: 2,
    	}
    	err := validate.Struct(s)
    	if err != nil {
    		fmt.Println(err)
    	}
    }

struct与map基于map规则验证

集合验证

  • map_validation.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    package validate

    import (
    	"log"
    )

    // 集合验证
    func ValidateMap() {
    	user := map[string]interface{}{
    		"name":  "mamamamama",
    		"email": "xx@xx.cn",
    	}
    	rules := map[string]interface{}{
    		"name":  "required,min=8,max=15",
    		"email": "omitempty,email",
    	}
    	err := validate.ValidateMap(user, rules)
    	if err != nil {
    		log.Fatal(err)
    	}
    }

    // 嵌套集合验证
    func ValidNestedMap() {
    	data := map[string]interface{}{
    		"name":  "niixx",
    		"email": "xx@ff.nn",
    		"details": map[string]interface{}{
    			"contact_address": map[string]interface{}{
    				"province": "hunan",
    				"city":     "changsha",
    			},
    			"age": 18,
    			"phones": []map[string]interface{}{
    				{
    					"number": "1-1111-111",
    					"remark": "home",
    				},
    				{
    					"number": "2-2222-111",
    					"remark": "work",
    				},
    			},
    		},
    	}

    	rules := map[string]interface{}{
    		"name":  "min=4,max=15",
    		"email": "required,email",
    		"details": map[string]interface{}{
    			"contact_address": map[string]interface{}{
    				"province": "required",
    				"city":     "required",
    			},
    			"age": "numeric,min=18",
    			"phones": map[string]interface{}{
    				"number": "required,min=4,max=32",
    				"remark": "required,min=1,max=32",
    			},
    		},
    	}
    	err := validate.ValidateMap(data, rules)
    	if err != nil {
    		log.Fatal(err)
    	}
    }

集合作为规则验证struct

  • map_rules.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    package validate

    import "fmt"

    type Data struct {
    	Name    string
    	Email   string
    	Details *Details
    }

    type Details struct {
    	ContactAddress *ContactAddress
    	Age            uint8
    	Phones         []*Phone
    }

    type ContactAddress struct {
    	Provice string
    	City    string
    }

    type Phone struct {
    	Number string
    	Remark string
    }

    func ValidateStructNested() {
    	data := Data{
    		Name:  "nixxx",
    		Email: "nii@ddx.cc",
    		Details: &Details{
    			ContactAddress: &ContactAddress{
    				Provice: "hunan",
    				City:    "changsha",
    			},
    			Age: 18,
    			Phones: []*Phone{
    				{
    					Number: "111-22222-333",
    					Remark: "home",
    				},
    				{
    					Number: "111-111122-333",
    					Remark: "work",
    				},
    			},
    		},
    	}
    	dataRules := map[string]string{
    		"Name":    "min=4,max=15",
    		"Email":   "required,email",
    		"Details": "required",
    	}
    	detailsRules := map[string]string{
    		"Age":            "number,min=18,max=130",
    		"ContactAddress": "required",
    		"Phones":         "required,min=1,dive",
    	}
    	contactAddressRules := map[string]string{
    		"Provice": "required",
    		"City":    "required",
    	}
    	phoneRules := map[string]string{
    		"Number": "required,min=4,max=15",
    		"Remark": "required,min=3,max=15",
    	}
    	validate.RegisterStructValidationMapRules(dataRules, Data{})
    	validate.RegisterStructValidationMapRules(detailsRules, Details{})
    	validate.RegisterStructValidationMapRules(contactAddressRules, ContactAddress{})
    	validate.RegisterStructValidationMapRules(phoneRules, Phone{})
    	err := validate.Struct(data)
    	if err != nil {
    		fmt.Println(err)
    	}
    }

根据locale本地化提示消息

  • translation.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    package validate

    import (
    	"fmt"

    	"github.com/go-playground/locales/en"
    	"github.com/go-playground/locales/zh"
    	ut "github.com/go-playground/universal-translator"
    	"github.com/go-playground/validator/v10"
    	en_tr "github.com/go-playground/validator/v10/translations/en"
    	zh_tr "github.com/go-playground/validator/v10/translations/zh"
    )

    // 提供通用内容的翻译，日期，金额等
    var (
    	uni *ut.UniversalTranslator
    )

    func Translation() {
    	local := "zh"
    	en := en.New()
    	zh := zh.New()
    	// 如果失败了支持那种，支持的语种...
    	uni = ut.New(en, zh, en)
    	// 获取指定语种的翻译
    	trans, _ := uni.GetTranslator(local)
    	switch local {
    	case "en": // 翻译器注册到验证器中
    		en_tr.RegisterDefaultTranslations(validate, trans)
    	case "zh":
    		zh_tr.RegisterDefaultTranslations(validate, trans)
    	default:
    		en_tr.RegisterDefaultTranslations(validate, trans)
    	}
    	// 验证提示语做翻译
    	translateAll(trans)
    	translateOverride(trans)
    }

    func translateAll(trans ut.Translator) {
    	type User struct {
    		UserName string `v:"required"`
    		Tagline  string `v:"required,lt=10"`
    		Tagline2 string `v:"required,gt=1"`
    	}
    	user := User{
    		UserName: "niii",
    		Tagline:  "xxxxxsiis",
    		Tagline2: "n",
    	}
    	err := validate.Struct(user)
    	// 1. 所有的错误提示一次性翻译
    	// 一次性将所有字段的提示消息翻译出来
    	// 错误提示从 切片 转为了集合
    	// if err != nil {
    	// 	errs := err.(validator.ValidationErrors)
    	// 	fmt.Println(errs.Translate(trans))
    	// }
    	// 2. 逐条翻译
    	if err != nil {
    		errs := err.(validator.ValidationErrors)
    		for _, e := range errs {
    			fmt.Println(e.Translate(trans))
    		}
    	}
    }

    // 3. 重写翻译器
    func translateOverride(trans ut.Translator) {
    	local := trans.Locale()
    	switch local {
    	case "en":
    		validate.RegisterTranslation("required", trans, func(ut ut.Translator) error {
    			return ut.Add("required", "{0} must have a value!--overried", true)
    		}, func(ut ut.Translator, fe validator.FieldError) string {
    			t, _ := ut.T("required", fe.Field())
    			return t
    		})
    	case "zh":
    		validate.RegisterTranslation("required", trans, func(ut ut.Translator) error {
    			return ut.Add("required", "{0} 必须有一个值!--overried", true)
    		}, func(ut ut.Translator, fe validator.FieldError) string {
    			t, _ := ut.T("required", fe.Field())
    			return t
    		})
    	}
    	type User struct {
    		UserName string `v:"required"`
    	}
    	var user User
    	err := validate.Struct(user)
    	if err != nil {
    		errs := err.(validator.ValidationErrors)
    		for _, e := range errs {
    			fmt.Println(e.Translate(trans))
    		}
    	}
    }

2024-12-11 该篇文章被 Cleofwine 归为分类: Go云原生

上一篇：【go工程组件】结构化日志记录logrus 下一篇：【go工程组件】轻量级认证机制jwt
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题