参数校验错误信息中文处理

在上一节咱们介绍到，gin能够使用ShouldBind方法把参数绑定到结构体，可是没有介绍到参数校验的方式，这节咱们来介绍参数校验和校验失败后转换成中文返回前端。

1.数据校验

下面咱们开始一个简单的例子：

1. 在根目录的requests目录下新建一个test_request.go

package requests

//测试请求结构体 该结构体定义了请求的参数和校验规则
type TestRequest struct {
    Username string `form:"username" binding:"required"`
}

1. 在根目录的api目录下新建一个test.go的控制器，定义test控制器

package api

import (
    "cn.sockstack/gin_demo/requests"
    "github.com/gin-gonic/gin"
    "net/http"
)

func Test(c *gin.Context)  {
    //实例化一个TestRequest结构体，用于接收参数
    testStruct := requests.TestRequest{}

    //接收请求参数
    err := c.ShouldBind(&testStruct)

    //判断参数校验是否经过，若是不经过，把错误返回给前端
    if err != nil {
        c.JSON(http.StatusOK, gin.H{"error": err.Error()})
        return
    }

    //校验经过，返回请求参数
    c.JSON(http.StatusOK, gin.H{"params": testStruct})
}

1. 在根目录的routers下定义/test路由，分别新建init.go和test.go文件初始化路由.

test.go

package routers

import (
    "cn.sockstack/gin_demo/api"
    "github.com/gin-gonic/gin"
)

func test(r *gin.Engine)  {
    //定义/test路由
    r.GET("/test", api.Test)
}

init.go

package routers

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

func Init(r *gin.Engine)  {
    //注册test路由
    test(r)
}

1. 在main.go中注册路由

package main
// 导入gin包
import (
    "cn.sockstack/gin_demo/pkg/config"
    "cn.sockstack/gin_demo/routers"
    "fmt"
    "github.com/gin-gonic/gin"
)

// 入口函数
func main() {
    // 初始化一个http服务对象
    r := gin.Default()

    //注册路由
    routers.Init(r)

    r.Run(fmt.Sprintf("%s:%d", config.Server.Address, config.Server.Port)) // 监听并在 0.0.0.0:8081 上启动服务
}

1. 运行并访问localhost:8081/test，不带参数会报错

{
    "error": "Key: 'TestRequest.Username' Error:Field validation for 'Username' failed on the 'required' tag"
}

1. 运行并访问localhost:8081/test?username=sockstack，则返回响应的参数。

{
    "params": {
        "Username": "sockstack"
    }
}

上面的例子已经能够实现参数校验和接收参数了，可是校验不经过的时候返回的提示是英文的，下面咱们介绍一下怎么把错误转成中文返回。

2.校验参数失败提示自动翻译

经过查看代码咱们发现gin默认的校验器使用的是validator包，而且查看文档发现validator是能够把英文错误翻译成中文的。

package main

import (
    "fmt"

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

// User contains user information
type User struct {
    FirstName      string     `validate:"required"`
    LastName       string     `validate:"required"`
    Age            uint8      `validate:"gte=0,lte=130"`
    Email          string     `validate:"required,email"`
    FavouriteColor string     `validate:"iscolor"`                // alias for 'hexcolor|rgb|rgba|hsl|hsla'
    Addresses      []*Address `validate:"required,dive,required"` // a person can have a home and cottage...
}

// Address houses a users address information
type Address struct {
    Street string `validate:"required"`
    City   string `validate:"required"`
    Planet string `validate:"required"`
    Phone  string `validate:"required"`
}

// use a single instance , it caches struct info
var (
    uni      *ut.UniversalTranslator
    validate *validator.Validate
)

func main() {

    // NOTE: ommitting allot of error checking for brevity

    en := en.New()
    uni = ut.New(en, en)

    // this is usually know or extracted from http 'Accept-Language' header
    // also see uni.FindTranslator(...)
    trans, _ := uni.GetTranslator("en")

    validate = validator.New()
    en_translations.RegisterDefaultTranslations(validate, trans)

    translateAll(trans)
    translateIndividual(trans)
    translateOverride(trans) // yep you can specify your own in whatever locale you want!
}

func translateAll(trans ut.Translator) {

    type User struct {
        Username string `validate:"required"`
        Tagline  string `validate:"required,lt=10"`
        Tagline2 string `validate:"required,gt=1"`
    }

    user := User{
        Username: "Joeybloggs",
        Tagline:  "This tagline is way too long.",
        Tagline2: "1",
    }

    err := validate.Struct(user)
    if err != nil {

        // translate all error at once
        errs := err.(validator.ValidationErrors)

        // returns a map with key = namespace & value = translated error
        // NOTICE: 2 errors are returned and you'll see something surprising
        // translations are i18n aware!!!!
        // eg. '10 characters' vs '1 character'
        fmt.Println(errs.Translate(trans))
    }
}

func translateIndividual(trans ut.Translator) {

    type User struct {
        Username string `validate:"required"`
    }

    var user User

    err := validate.Struct(user)
    if err != nil {

        errs := err.(validator.ValidationErrors)

        for _, e := range errs {
            // can translate each error one at a time.
            fmt.Println(e.Translate(trans))
        }
    }
}

func translateOverride(trans ut.Translator) {

    validate.RegisterTranslation("required", trans, func(ut ut.Translator) error {
        return ut.Add("required", "{0} must have a value!", true) // see universal-translator for details
    }, func(ut ut.Translator, fe validator.FieldError) string {
        t, _ := ut.T("required", fe.Field())

        return t
    })

    type User struct {
        Username string `validate:"required"`
    }

    var user User

    err := validate.Struct(user)
    if err != nil {

        errs := err.(validator.ValidationErrors)

        for _, e := range errs {
            // can translate each error one at a time.
            fmt.Println(e.Translate(trans))
        }
    }
}

那么咱们改造gin的校验提示。

1. 在requests目录下新建init.go文件

package requests

import (
   "github.com/gin-gonic/gin/binding"
   "github.com/go-playground/locales/zh"
   ut "github.com/go-playground/universal-translator"
   "github.com/go-playground/validator/v10"
   zh_translations "github.com/go-playground/validator/v10/translations/zh"
)

var (
   uni      *ut.UniversalTranslator
   validate *validator.Validate
   trans ut.Translator
)

func init() {
   //注册翻译器
   zh := zh.New()
   uni = ut.New(zh, zh)

   trans, _ = uni.GetTranslator("zh")
   
   //获取gin的校验器
   validate := binding.Validator.Engine().(*validator.Validate)
   //注册翻译器
   zh_translations.RegisterDefaultTranslations(validate, trans)
}

//Translate 翻译错误信息
func Translate(err error) map[string][]string {
   var result = make(map[string][]string)

   errors := err.(validator.ValidationErrors)

   for _, err := range errors{
      result[err.Field()] = append(result[err.Field()], err.Translate(trans))
   }
   return result
}

1. 修改控制器

package api

import (
    "cn.sockstack/gin_demo/requests"
    "github.com/gin-gonic/gin"
    "net/http"
)

func Test(c *gin.Context)  {
    //实例化一个TestRequest结构体，用于接收参数
    testStruct := requests.TestRequest{}

    //接收请求参数
    err := c.ShouldBind(&testStruct)

    //判断参数校验是否经过，若是不经过，把错误返回给前端
    if err != nil {
        c.JSON(http.StatusOK, gin.H{"error": requests.Translate(err)})
        return
    }

    //校验经过，返回请求参数
    c.JSON(http.StatusOK, gin.H{"params": testStruct})
}

1. 运行并访问localhost:8081/test，不带参数会报错，可是报错信息已经翻译成中文了

{
    "error": {
        "Username": [
            "Username为必填字段"
        ]
    }
}

出处 gin从入门到实践更多精彩文章，请关注个人博客 SOCKSTACK，分享个人工做经验。