使用中间件比使用函数（utils作为包名也不受欢迎）更习惯：

func ErrorHandler(c *gin.Context) {
        c.Next()

        for _, err := range c.Errors {
            // log, handle, etc.
        }
    
        c.JSON(http.StatusInternalServerError, "")
}

func main() {
    router := gin.New()
    router.Use(middleware.ErrorHandler)
    // ... routes
}

值得注意的是，您在中间件func**内部调用c.Next()，然后才调用实际的错误处理代码，因此您要确保在调用了处理程序链的其余部分之后才进行错误处理。
Next应该只在中间件内部使用。它在调用处理程序内部执行链中的挂起处理程序。[...]
使用中间件的好处是，你也可以传递参数给它，例如一个logger，你可能想稍后使用它作为错误处理的一部分，once，而不是每次直接调用utils.ErrorHandler时都传递它。在这个例子中，它看起来像这样（我使用Uber Zap loggers）：

func ErrorHandler(logger *zap.Logger) gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Next()
        
        for _, ginErr := range c.Errors {
            logger.Error("whoops", ...)
        }
    }
}

func main() {
    router := gin.New()
    
    logger, _ := zap.NewDevelopment()

    router.Use(middleware.ErrorHandler(logger))
    // ... routes
}

然后处理程序将中止链，而不是调用函数，这样看起来更干净，也更容易维护：

func (h *Handler) List(c *gin.Context) {
    movies, err := h.service.ListService()

    if err != nil {
        c.AbortWithError(http.StatusInternalServerError, err)
        return
    }

    c.JSON(http.StatusOK, movies)
}

需要注意的是，如果你在c.AbortWithStatus或c.AbortWithError中设置了一个HTTP状态，你可能希望不要在错误处理程序中覆盖它，在这种情况下，你可以使用-1作为状态代码来调用c.JSON()：

func ErrorHandler(logger *zap.Logger) gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Next()
        
        for _, ginErr := range c.Errors {
            logger.Error("whoops", ...)
        }

        // status -1 doesn't overwrite existing status code
        c.JSON(-1, /* error payload */)
    }
}

最后，使用中间件允许您在处理程序中多次调用c.Error，例如，当发生一系列非致命错误，并且您希望在实际中止请求之前捕获所有错误时。
Error将一个错误附加到当前上下文。该错误将被推送到错误列表中。最好为解析请求过程中发生的每个错误调用Error。可以使用中间件来收集所有错误并[处理它们]

func (h *Handler) List(c *gin.Context) {
    err1 := /* non-fatal error */
    if err1 != nil {
        c.Error(err1)
    }

    err2 := /* another non-fatal error */
    if err2 != nil {
        c.Error(err2)
    }

    fatalErr := /* fatal error */
    if fatalErr != nil {
        c.AbortWithError(505, fatalErr)
        return
        // the error handler will have collected all 3 errors
    }

    c.JSON(http.StatusOK, movies)
}

至于中间件中的实际错误处理，它非常简单，只需记住，所有对c.Error、c.AbortWith...的调用都会将您的错误 Package 在gin.Error中，因此要检查原始值，您必须检查err.Err字段：

func ErrorHandler(c *gin.Context) {
        c.Next()

        for _, err := range c.Errors {
            switch err.Err {
                case ErrNotFound:
                  c.JSON(-1, gin.H{"error": ErrNotFound.Error()})  
            }
            // etc...
        }

        c.JSON(http.StatusInternalServerError, "")
}

在c.Errors上迭代可能看起来有些笨拙，因为现在您可能有N个错误而不是一个，但是根据您打算如何使用中间件，您可以简单地检查len(c.Errors) > 0并只访问第一项c.Errors[0]。

在中间件中处理错误的好处是集中处理错误，而不是在每个处理程序中显式处理异常。
为了减少响应Map错误，提出了一种相关的错误处理中间件gin-error。

func Error(errM ...*ErrorMap) gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Next()

        lastError := c.Errors.Last()
        if lastError == nil {
            return
        }

        for _, err := range errM {
            for _, e := range err.errors {
                if e == lastError.Err || errors.Is(e, lastError.Err) {
                    err.response(c)
                }
            }
        }
    }
}

使用示例：

• 您可以将错误Map到一个状态代码

import (
    "github.com/richzw/gin-error"
    "github.com/gin-gonic/gin"
)
var BadRequestErr = fmt.Errorf("bad request error")

func main() {
    r := gin.Default()
    r.Use(err.Error(err.NewErrMap(BadRequestErr).StatusCode(http.StatusBadRequest)))

    r.GET("/test", func(c *gin.Context) {
        c.Error(BadRequestErr)
    })

    r.Run()
}

• 或将错误Map到一个响应

import (
    "github.com/richzw/gin-error"
    "github.com/gin-gonic/gin"
)
var BadRequestErr = fmt.Errorf("bad request error")

func main() {
    r := gin.Default()
    r.Use(err.Error(
        err.NewErrMap(BadRequestErr).Response(func(c *gin.Context) {
            c.JSON(http.StatusBadRequest, gin.H{"error": BadRequestErr.Error()})
        })))

    r.GET("/test", func(c *gin.Context) {
        c.Error(BadRequestErr)
    })

    r.Run()
}