路由与中间件

1. 路由分组

路由分组可以帮助组织路由和共享中间件：

func main() {
    r := gin.Default()
    
    // 公共路由组
    public := r.Group("/api")
    {
        public.GET("/login", login)
        public.GET("/register", register)
    }
    
    // 私有路由组(需要认证)
    private := r.Group("/api")
    private.Use(AuthMiddleware()) // 应用认证中间件
    {
        private.GET("/profile", profile)
        private.POST("/settings", updateSettings)
    }
    
    r.Run(":8080")
}

2. 中间件基础

中间件是处理请求和响应的函数链：

func LoggerMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 请求前处理
        start := time.Now()
        path := c.Request.URL.Path
        
        // 调用下一个处理程序
        c.Next()
        
        // 请求后处理
        latency := time.Since(start)
        fmt.Printf("%s %s %s\n", 
            c.Request.Method, 
            path, 
            latency)
    }
}

3. 常用内置中间件

Gin提供了一些有用的内置中间件：

func main() {
    // 使用Logger中间件记录请求日志
    r := gin.Default()
    
    // 使用Recovery中间件从panic恢复
    r.Use(gin.Recovery())
    
    // 静态文件服务中间件
    r.Use(gin.Static("/public", "./assets"))
    
    r.Run(":8080")
}

4. 自定义中间件示例

认证中间件

func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        if token != "valid_token" {
            c.AbortWithStatusJSON(401, gin.H{
                "error": "Unauthorized",
            })
            return
        }
        c.Next()
    }
}

限流中间件

func RateLimitMiddleware(limit int) gin.HandlerFunc {
    bucket := make(chan struct{}, limit)
    return func(c *gin.Context) {
        select {
        case bucket <- struct{}{}:
            defer func() { <-bucket }()
            c.Next()
        default:
            c.AbortWithStatusJSON(429, gin.H{
                "error": "Too many requests",
            })
        }
    }
}

5. 中间件执行顺序

中间件按照添加顺序执行：

func main() {
    r := gin.New()
    
    // 第一个执行的中间件
    r.Use(func(c *gin.Context) {
        fmt.Println("Middleware 1 - Start")
        c.Next()
        fmt.Println("Middleware 1 - End")
    })
    
    // 第二个执行的中间件
    r.Use(func(c *gin.Context) {
        fmt.Println("Middleware 2 - Start")
        c.Next()
        fmt.Println("Middleware 2 - End")
    })
    
    r.GET("/", func(c *gin.Context) {
        fmt.Println("Handler")
        c.String(200, "Hello")
    })
    
    r.Run(":8080")
}

输出顺序：

Middleware 1 - Start
Middleware 2 - Start
Handler
Middleware 2 - End
Middleware 1 - End

提示：合理使用中间件可以极大提高代码复用率和可维护性，但也要避免过度使用导致性能下降。