Go Gin框架中如何根据请求来源条件加载中间件？

Gin的中间件链是在服务启动前就确定并编译完成的，请求处理过程中动态调用r.Use()无法修改当前请求的中间件执行顺序，所以你之前的尝试不会生效。下面是几种可行的实现方案：

方案一：直接在中间件中条件执行session逻辑 #

把session中间件的核心逻辑封装成独立函数，在自定义中间件里根据判断结果决定是否执行该逻辑，这是最直接的方式：

// 封装session中间件的核心处理逻辑
func handleSession(c *gin.Context) {
    // 这里替换成你实际的session中间件代码
    store := sessions.Default(c)
    // 示例：获取或创建会话
    if sessionID := store.Get("session_id"); sessionID == nil {
        store.Set("session_id", uuid.New().String())
        _ = store.Save()
    }
}

func MyMiddleware(c *gin.Context) {
    isFromFrontend := myFunctionToDetermine() // 你的判断逻辑
    c.Set("isFromFrontend", isFromFrontend)
    
    if isFromFrontend {
        handleSession(c) // 条件触发session处理
    }
    
    c.Next()
}

func main() {
    r := gin.Default()
    r.Use(MyMiddleware)
    
    // 后续路由定义...
    r.Run(":8080")
}

方案二：拆分路由组区分处理 #

如果SPA请求有统一的路径前缀（比如/spa/），可以直接创建两个路由组，分别配置不同的中间件：

func main() {
    r := gin.Default()
    
    // 非SPA请求组：不加载session中间件
    nonSPAGroup := r.Group("/")
    nonSPAGroup.Use(func(c *gin.Context) {
        c.Set("isFromFrontend", false)
        c.Next()
    })
    nonSPAGroup.GET("/api/public", func(c *gin.Context) {
        c.JSON(200, gin.H{"msg": "public api"})
    })
    
    // SPA请求组：加载session中间件
    spaGroup := r.Group("/spa")
    spaGroup.Use(func(c *gin.Context) {
        c.Set("isFromFrontend", true)
        c.Next()
    }, sessions.Sessions("session", store)) // 你的session中间件
    spaGroup.GET("/dashboard", func(c *gin.Context) {
        c.JSON(200, gin.H{"msg": "spa dashboard"})
    })
    
    r.Run(":8080")
}

如果没有统一前缀，可以通过前置中间件判断后转发请求到对应路由组：

func main() {
    r := gin.Default()
    
    spaGroup := r.Group("/internal/spa")
    spaGroup.Use(sessions.Sessions("session", store))
    spaGroup.GET("/dashboard", func(c *gin.Context) {
        c.JSON(200, gin.H{"msg": "spa dashboard"})
    })
    
    nonSPAGroup := r.Group("/internal/nonspa")
    nonSPAGroup.GET("/public", func(c *gin.Context) {
        c.JSON(200, gin.H{"msg": "public api"})
    })
    
    // 前置判断中间件
    r.Use(func(c *gin.Context) {
        isFromFrontend := myFunctionToDetermine()
        c.Set("isFromFrontend", isFromFrontend)
        
        if isFromFrontend {
            // 转发到SPA组
            c.Request.URL.Path = "/internal/spa" + c.Request.URL.Path
            spaGroup.HandleContext(c)
            c.Abort() // 终止原链执行
        } else {
            // 转发到非SPA组
            c.Request.URL.Path = "/internal/nonspa" + c.Request.URL.Path
            nonSPAGroup.HandleContext(c)
            c.Abort()
        }
    })
    
    r.Run(":8080")
}

方案三：自定义session中间件内置判断逻辑 #

直接修改session中间件，让它自己判断是否需要执行会话处理：

func ConditionalSessionMiddleware(store sessions.Store) gin.HandlerFunc {
    return func(c *gin.Context) {
        isFromFrontend := myFunctionToDetermine()
        c.Set("isFromFrontend", isFromFrontend)
        
        if isFromFrontend {
            // 执行session中间件逻辑
            sessions.Sessions("session", store)(c)
        } else {
            c.Next()
        }
    }
}

func main() {
    r := gin.Default()
    r.Use(ConditionalSessionMiddleware(store))
    
    // 路由定义...
    r.Run(":8080")
}

内容的提问来源于stack exchange，提问作者Poseidon