Golang Gin框架中的请求拦截与全局异常处理

在Golang Gin框架中，如何优雅地实现请求拦截和全局异常处理？目前我在中间件中尝试拦截请求并进行权限验证，但遇到两个问题：1) 如何在拦截到非法请求时统一返回错误格式而不是直接abort？2) 全局异常处理时，怎样避免在每个handler中都写重复的recover逻辑，同时还能捕获到具体的错误堆栈信息？希望了解最佳实践方案，特别是针对RESTful API的场景。

3 回复

在Gin框架中，可以通过中间件实现请求拦截和全局异常处理。

请求拦截：

  1. 使用 gin.HandlerFunc 定义中间件。例如：
    func CORSMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
        if c.Request.Method == "OPTIONS" {
            c.AbortWithStatus(204)
            return
        }
        c.Next()
    }
}
    在路由注册时应用该中间件，如：
    r := gin.Default()
r.Use(CORSMiddleware())

全局异常处理：

  1. 在中间件或路由处理函数中捕获错误并统一返回。例如：
    func RecoveryMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        defer func() {
            if err := recover(); err != nil {
                c.JSON(500, gin.H{"error": "Internal Server Error"})
                c.Abort()
            }
        }()
        c.Next()
    }
}
    注册中间件：
    r.Use(RecoveryMiddleware())

通过这种方式，可以集中管理请求拦截和异常处理，提高代码的可维护性和一致性。

更多关于Golang Gin框架中的请求拦截与全局异常处理的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Gin框架中，可以通过中间件实现请求拦截和全局异常处理。

请求拦截： 创建一个中间件函数，例如middleware.go：

func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 获取token或验证用户身份
        token := c.Request.Header.Get("Authorization")
        if token == "" {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "未授权"})
            c.Abort()
            return
        }
        // 继续执行后续逻辑
        c.Next()
    }
}

然后在路由注册时使用该中间件：

r := gin.Default()
r.Use(AuthMiddleware())

全局异常处理： 同样通过中间件实现：

func RecoveryMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        defer func() {
            if err := recover(); err != nil {
                c.JSON(http.StatusInternalServerError, gin.H{"error": "服务器内部错误"})
                c.Abort()
            }
        }()
        c.Next()
    }
}

注册中间件：

r.Use(RecoveryMiddleware())

这样可以捕获所有未处理的异常并返回统一的错误响应。

在Gin框架中，可以通过中间件(Middleware)来实现请求拦截和全局异常处理。以下是具体实现方式：

  1. 请求拦截（中间件）
func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 在此验证token等逻辑
        token := c.GetHeader("Authorization")
        if token == "" {
            c.AbortWithStatusJSON(401, gin.H{"error": "未授权"})
            return
        }
        
        // 验证通过则继续处理
        c.Next()
    }
}
  1. 全局异常处理
func RecoveryMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        defer func() {
            if err := recover(); err != nil {
                c.AbortWithStatusJSON(500, gin.H{
                    "code": 500,
                    "msg": "服务器内部错误",
                })
            }
        }()
        c.Next()
    }
}
  1. 注册中间件
func main() {
    r := gin.Default()
    
    // 全局中间件
    r.Use(RecoveryMiddleware())
    
    // 路由组中间件
    api := r.Group("/api")
    api.Use(AuthMiddleware())
    {
        api.GET("/user", getUser)
    }
    
    r.Run()
}

关键点：

  1. 中间件通过c.Next()继续处理请求
  2. 使用c.Abort()可以中断请求
  3. recover()能捕获panic异常
  4. 中间件可通过Use()方法全局注册或路由组注册

这种方式可以实现统一的权限验证、日志记录和异常处理。

回到顶部