自定义规则分为两种：全局规则注册和局部规则注册。

全局校验规则注册

全局规则是全局生效的规则，注册之后无论是使用方法还是对象来执行数据校验都可以使用自定义的规则。

注册校验方法：

  1. // RegisterRule registers custom validation rule and function for package.
  2. // It returns error if there's already the same rule registered previously.
  3. func RegisterRule(rule string, f RuleFunc) error

校验方法定义：

  1. // RuleFunc is the custom function for data validation.
  2. // The parameter `rule` specifies the validation rule string, like "required", "between:1,100", etc.
  3. // The parameter `value` specifies the value for this rule to validate.
  4. // The parameter `message` specifies the custom error message or configured i18n message for this rule.
  5. // The parameter `data` specifies the `data` which is passed to the Validator. It might be type of map/struct or a nil value.
  6. // You can ignore the parameter `data` if you do not really need it in your custom validation rule.
  7. type RuleFunc func(ctx context.Context, rule string, value interface{}, message string, data interface{}) error

简要说明：

  1. 您需要按照RuleFunc类型的方法定义，实现一个您需要的校验方法，随后使用RegisterRule注册到gvalid模块中全局管理。该注册逻辑往往是在程序初始化时执行。该方法在对数据进行校验时将会被自动调用，方法返回nil表示校验通过，否则应当返回一个非空的error类型值。
  2. 参数说明：
    • ctx表示当前链路的上下文变量。
    • rule参数表示当前的校验规则，包含规则的参数，例如：required, between:1,100, length:6等等。
    • value参数表示被校验的数据值，注意类型是一个interface{}，因此您可以传递任意类型的参数，并在校验方法内部按照程序使用约定自行进行转换（往往使用gconv模块实现转换）。
    • message参数表示在校验失败后返回的校验错误提示信息，往往在struct定义时使用gvalid tag来通过标签定义。
    • data参数表示校验时传递的参数，例如校验的是一个map或者struct时，往往在联合校验时有用。需要注意的是，这个值是运行时输入的，值可能是nil。

自定义错误默认情况下已支持i18n特性，因此您只需要按照 gf.gvalid.rule.自定义规则名称 配置i18n转译信息即可，该信息在校验失败时自动从i18n管理器获取后，通过message参数传入给您注册的自定义校验方法中。

注意事项：自定义规则的注册方法不支持并发调用，您需要在程序启动时进行注册（例如在boot包中处理），无法在运行时动态注册，否则会产生并发安全问题。

示例1，用户唯一性规则

在用户注册时，我们往往需要校验当前用户提交的名称/账号是否唯一，因此我们可以注册一个unique-name的全局规则来实现。

  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "github.com/gogf/gf/util/gvalid"
  8.     "github.com/gogf/gf/errors/gerror"
  9.     "github.com/gogf/gf/frame/g"
  10.     "github.com/gogf/gf/util/gconv"
  11. )
  13. type User struct {
  14.     Id   int
  15.     Name string `v:"required|unique-name # 请输入用户名称|用户名称已被占用"`
  16.     Pass string `v:"required|length:6,18"`
  17. }
  19. func init() {
  20.     rule := "unique-name"
  21.     if err := gvalid.RegisterRule(rule, UniqueNameChecker); err != nil {
  22.         panic(err)
  23.     }
  24. }
  26. func UniqueNameChecker(ctx context.Context, rule string, value interface{}, message string, data interface{}) error {
  27.     user := &User{}
  28.     if v, ok := data.(*User); ok {
  29.         user = v
  30.     }
  31.     // SELECT COUNT(*) FROM `user` WHERE `id` != xxx AND `name` != xxx
  32.     count, err := g.Model("user").
  33.         Ctx(ctx).
  34.         WhereNot("id", user.Id).
  35.         WhereNot("name", gconv.String(value)).
  36.         Count()
  37.     if err != nil {
  38.         return err
  39.     }
  40.     if count > 0 {
  41.         return gerror.New(message)
  42.     }
  43.     return nil
  44. }
  46. func main() {
  47.     user := &User{
  48.         Id:   1,
  49.         Name: "john",
  50.         Pass: "123456",
  51.     }
  52.     err := g.Validator().CheckStruct(user)
  53.     fmt.Println(err)
  54. }

示例2，自定义覆盖required规则

默认情况下，gvalid的内置规则是不支持map、slice类型的required规则校验，因此我们可以自行实现，然后覆盖原有规则（这里需要用到反射）。其他的规则也可以按照此逻辑自定义覆盖。

  1. package main
  3. import (
  4.     "context"
  5.     "errors"
  6.     "fmt"
  7.     "github.com/gogf/gf/util/gvalid"
  8.     "math"
  9.     "reflect"
  11.     "github.com/gogf/gf/frame/g"
  12. )
  14. func init() {
  15.     rule := "required"
  16.     if err := gvalid.RegisterRule(rule, RequiredChecker); err != nil {
  17.         panic(err)
  18.     }
  19. }
  21. func RequiredChecker(ctx context.Context, rule string, value interface{}, message string, data interface{}) error {
  22.     reflectValue := reflect.ValueOf(value)
  23.     if reflectValue.Kind() == reflect.Ptr {
  24.         reflectValue = reflectValue.Elem()
  25.     }
  26.     isEmpty := false
  27.     switch reflectValue.Kind() {
  28.     case
  29.         reflect.Bool:
  30.         isEmpty = !reflectValue.Bool()
  32.     case
  33.         reflect.Int,
  34.         reflect.Int8,
  35.         reflect.Int16,
  36.         reflect.Int32,
  37.         reflect.Int64:
  38.         isEmpty = reflectValue.Int() == 0
  40.     case
  41.         reflect.Uint,
  42.         reflect.Uint8,
  43.         reflect.Uint16,
  44.         reflect.Uint32,
  45.         reflect.Uint64,
  46.         reflect.Uintptr:
  47.         isEmpty = reflectValue.Uint() == 0
  49.     case
  50.         reflect.Float32,
  51.         reflect.Float64:
  52.         isEmpty = math.Float64bits(reflectValue.Float()) == 0
  54.     case
  55.         reflect.Complex64,
  56.         reflect.Complex128:
  57.         c := reflectValue.Complex()
  58.         isEmpty = math.Float64bits(real(c)) == 0 && math.Float64bits(imag(c)) == 0
  60.     case
  61.         reflect.String,
  62.         reflect.Map,
  63.         reflect.Array,
  64.         reflect.Slice:
  65.         isEmpty = reflectValue.Len() == 0
  66.     }
  67.     if isEmpty {
  68.         return errors.New(message)
  69.     }
  70.     return nil
  71. }
  73. func main() {
  74.     fmt.Println(g.Validator().Rules("required").Messages("It's required").CheckValue(""))
  75.     fmt.Println(g.Validator().Rules("required").Messages("It's required").CheckValue([]string{}))
  76.     fmt.Println(g.Validator().Rules("required").Messages("It's required").CheckValue(map[string]int{}))
  77. }

执行后，终端输出：

  1. It's required
  2. It's required
  3. It's required

局部校验规则注册

局部规则是仅在当前校验对象下生效规则，校验规则是注册到对象下而不是全局中。

注册方法：

  1. // RuleFunc registers one custom rule function to current Validator.
  2. func (v *Validator) RuleFunc(rule string, f RuleFunc) *Validator
  4. // RuleFuncMap registers multiple custom rule functions to current Validator.
  5. func (v *Validator) RuleFuncMap(m map[string]RuleFunc) *Validator

简要介绍：

  • RuleFunc方法用于注册单个自定义校验规则到当前对象。
  • RuleFuncMap方法用于注册多个自定义校验规则到当前对象。

使用示例：

我们将上面的例子改为局部校验规则注册。

  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "github.com/gogf/gf/errors/gerror"
  7.     "github.com/gogf/gf/frame/g"
  8.     "github.com/gogf/gf/util/gconv"
  9. )
  11. type User struct {
  12.     Id   int
  13.     Name string `v:"required|unique-name # 请输入用户名称|用户名称已被占用"`
  14.     Pass string `v:"required|length:6,18"`
  15. }
  17. func UniqueNameChecker(ctx context.Context, rule string, value interface{}, message string, data interface{}) error {
  18.     user := &User{}
  19.     if v, ok := data.(*User); ok {
  20.         user = v
  21.     }
  22.     // SELECT COUNT(*) FROM `user` WHERE `id` != xxx AND `name` != xxx
  23.     count, err := g.Model("user").
  24.         Ctx(ctx).
  25.         WhereNot("id", user.Id).
  26.         WhereNot("name", gconv.String(value)).
  27.         Count()
  28.     if err != nil {
  29.         return err
  30.     }
  31.     if count > 0 {
  32.         return gerror.New(message)
  33.     }
  34.     return nil
  35. }
  37. func main() {
  38.     user := &User{
  39.         Id:   1,
  40.         Name: "john",
  41.         Pass: "123456",
  42.     }
  43.     err := g.Validator().RuleFunc("unique-name", UniqueNameChecker).CheckStruct(user)
  44.     fmt.Println(err)
  45. }

Content Menu