如何在被 gin c.BindJSON 捕获时断言错误类型 json.UnmarshalTypeError

Question

我正在尝试使用 gin gonic 捕获绑定错误，它可以很好地处理来自 go-playground/validator/v10 的所有验证错误，但是在解组为正确的数据类型时我遇到了捕获错误的问题。

结构字段验证不成功将 return 使用验证器标签时出现 gin.ErrorTypeBind 类型的错误（必需，...）

但是如果我有一个结构

type Foo struct {
  ID int `json:"id"`
  Bar string `json:"bar"`
}

我要传递的 json 格式错误（传递的是字符串而不是 id 的数字）

{
    "id":"string",
    "bar":"foofofofo"
}

它将因错误而失败 json: cannot unmarshal string into Go struct field Foo.id of type int

它仍然在我的处理程序中被捕获为 gin.ErrorTypeBind 作为绑定错误，但由于我需要区分验证错误和解组错误，我遇到了问题。

我已经尝试过验证错误时的类型转换不适用于解组： e.Err.(validator.ValidationErrors) 会恐慌

或者只是 errors.Is 但这根本不会捕获错误

    if errors.Is(e.Err, &json.UnmarshalTypeError{}) {
        log.Println("Json binding error")
    }

我这样做的目的是 return 向用户提供格式正确的错误消息。它目前适用于所有验证逻辑，但我似乎无法让它适用于 json 数据，因为不正确的数据会发送给我。

有什么想法吗？

编辑：

添加示例以重现：

package main

import (
    "encoding/json"
    "errors"
    "log"
    "net/http"

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

type Foo struct {
    ID  int    `json:"id" binding:"required"`
    Bar string `json:"bar"`
}

func FooEndpoint(c *gin.Context) {
    var fooJSON Foo
    err := c.BindJSON(&fooJSON)
    if err != nil {
        // caught and answer in the error MW
        return
    }
    c.JSON(200, "test")
}

func main() {
    api := gin.Default()
    api.Use(ErrorMW())
    api.POST("/foo", FooEndpoint)
    api.Run(":5000")
}

func ErrorMW() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Next()
        if len(c.Errors) > 0 {
            for _, e := range c.Errors {
                switch e.Type {
                case gin.ErrorTypeBind:
                    log.Println(e.Err)
                    var jsonErr json.UnmarshalTypeError
                    if errors.Is(e.Err, &jsonErr) {
                        log.Println("Json binding error")
                    }
                    // if errors.As(e.Err, &jsonErr) {
                    //  log.Println("Json binding error")
                    // }
                    // in reality i'm making it panic.
                    // errs := e.Err.(validator.ValidationErrors)
                    errs, ok := e.Err.(validator.ValidationErrors)
                    if ok {
                        log.Println("error trying to cast validation type")
                    }
                    log.Println(errs)
                    status := http.StatusBadRequest
                    if c.Writer.Status() != http.StatusOK {
                        status = c.Writer.Status()
                    }
                    c.JSON(status, gin.H{"error": "error"})
                default:
                    log.Println("other error")
                }

            }
            if !c.Writer.Written() {
                c.JSON(http.StatusInternalServerError, gin.H{"Error": "internal error"})
            }
        }
    }
}

尝试发送带有正文的 post 请求

{
  "id":"rwerewr",
   "bar":"string"
}

interface conversion: error is *json.UnmarshalTypeError, not validator.ValidationErrors

这会起作用：

{
  "id":1,
   "bar":"string"
}

这将（理所当然地）return Key: 'Foo.ID' Error:Field validation for 'ID' failed on the 'required' tag

{ “酒吧”：“字符串” }

Answer 1

errors.Is 寻找完全匹配（在您的情况下，json.UnmarshalTypeError 的空实例）。使用 errors.As 代替：

var jsonErr *json.UnmarshalTypeError
if errors.As(e.Err, &jsonErr) {
    log.Println("Json binding error")
}

Playground example

然而，正如@LeGEC 所指出的，这假设 gin 的错误符合标准 Unwrapper 接口，但它们不符合。

Answer 2

[更新]：sice 版本 1.7.0, which itegrates this PR，现在可以在 gin.Error.

上使用 errors.Is / errors.As

所以你可以这样写：

err := c.BindJson(&fooJson)

if err != nil {
var jsErr *json.UnmarshalTypeError
  if errors.As(err, &jsErr) {
    fmt.Println("the json is invalid")
  } else {
    fmt.Println("this is something else")
  }
}

[编辑]：嗯，它不会修复@Flimzy 的答案：查看 the docs、gin.Error 没有实现 .Unwrap() 方法。

您必须先将错误转换为 gin.Error，然后检查 ginErr.Err :

// you can probably work with straight conversion from interface to target type :
if g, ok := err.(*gin.Error); ok {
    if _, ok := g.Err.(*json.UnmarshalTypeError); ok {
        log.Println("Json binding error")
    }
}

// or use errors.As() :
var g *gin.Error
if errors.As(err, &g) {
    var j *json.UnmarshalTypeError
    if errors.As(g.Err, &j) {
        log.Println("Json binding error")
    }
}

我的初始答案：

（修正@Fllimzy 的回答）

使用errors.As
因为 json.UnmarshalTypeError 是一个结构（不是接口），你必须明确区分 json.UnmarshalTypeError 和 *json.UnmarshalTypeError

尝试运行 :

var jsonErr *json.UnmarshalTypeError  // emphasis on the '*'
if errors.As(e.Err, &jsonErr) {
    log.Println("Json binding error")
}

下面是 errors.As() 行为的说明：
https://play.golang.org/p/RVz6xop5k4u

如何在被 gin c.BindJSON 捕获时断言错误类型 json.UnmarshalTypeError

How to assert error type json.UnmarshalTypeError when caught by gin c.BindJSON

json

validation

go

error-handling

go-gin