Gin 框架中间件详细介绍

基本中间件结构：

// 基本中间件函数签名
func MiddlewareName() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 处理请求前的逻辑
        
        c.Next()  // 处理下一个中间件或处理函数
        
        // 处理请求后的逻辑
    }
}

常用中间件示例：

package middleware

import (
    "github.com/gin-gonic/gin"
    "log"
    "time"
)

// 日志中间件
func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        path := c.Request.URL.Path
        
        c.Next()
        
        latency := time.Since(start)
        statusCode := c.Writer.Status()
        log.Printf("Path: %s | Status: %d | Latency: %v", path, statusCode, latency)
    }
}

// 认证中间件
func Auth() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        if token == "" {
            c.JSON(401, gin.H{"error": "Authorization token required"})
            c.Abort()
            return
        }
        
        // 验证 token
        if !validateToken(token) {
            c.JSON(401, gin.H{"error": "Invalid token"})
            c.Abort()
            return
        }
        
        c.Next()
    }
}

// 错误处理中间件
func ErrorHandler() gin.HandlerFunc {
    return func(c *gin.Context) {
        defer func() {
            if err := recover(); err != nil {
                c.JSON(500, gin.H{
                    "error": "Internal Server Error",
                })
            }
        }()
        c.Next()
    }
}

// CORS 中间件
func CORS() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
        c.Writer.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
        
        if c.Request.Method == "OPTIONS" {
            c.AbortWithStatus(204)
            return
        }
        
        c.Next()
    }
}

中间件的使用方式：

package main

import (
    "github.com/gin-gonic/gin"
    "your-project/middleware"
)

func main() {
    r := gin.Default()
    
    // 全局中间件
    r.Use(middleware.Logger())
    r.Use(middleware.ErrorHandler())
    
    // 路由组中间件
    authorized := r.Group("/api")
    authorized.Use(middleware.Auth())
    {
        authorized.GET("/users", GetUsers)
        authorized.POST("/users", CreateUser)
    }
    
    // 单个路由中间件
    r.GET("/public", middleware.CORS(), PublicHandler)
    
    r.Run(":8080")
}

带配置的中间件：

// 限流中间件
func RateLimit(limit int, duration time.Duration) gin.HandlerFunc {
    limiter := rate.NewLimiter(rate.Every(duration), limit)
    
    return func(c *gin.Context) {
        if !limiter.Allow() {
            c.JSON(429, gin.H{"error": "Too many requests"})
            c.Abort()
            return
        }
        c.Next()
    }
}

// 缓存中间件
func Cache(duration time.Duration) gin.HandlerFunc {
    cache := make(map[string]cacheEntry)
    
    type cacheEntry struct {
        data      interface{}
        timestamp time.Time
    }
    
    return func(c *gin.Context) {
        key := c.Request.URL.Path
        
        // 检查缓存
        if entry, exists := cache[key]; exists {
            if time.Since(entry.timestamp) < duration {
                c.JSON(200, entry.data)
                c.Abort()
                return
            }
        }
        
        c.Next()
        
        // 存储响应到缓存
        cache[key] = cacheEntry{
            data:      c.Keys["response"],
            timestamp: time.Now(),
        }
    }
}

自定义上下文：

// 自定义上下文
type CustomContext struct {
    *gin.Context
    User *models.User
}

// 用户上下文中间件
func UserContext() gin.HandlerFunc {
    return func(c *gin.Context) {
        user := getCurrentUser(c)
        customContext := &CustomContext{
            Context: c,
            User:    user,
        }
        
        c.Set("custom_context", customContext)
        c.Next()
    }
}

链式中间件：

// 请求链路追踪
func RequestTracing() gin.HandlerFunc {
    return func(c *gin.Context) {
        traceID := generateTraceID()
        c.Set("trace_id", traceID)
        
        c.Next()
        
        // 记录请求完成
        log.Printf("Request completed: %s", traceID)
    }
}

// 性能监控中间件
func Performance() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        
        c.Next()
        
        duration := time.Since(start)
        if duration > time.Second {
            log.Printf("Slow request: %s took %v", c.Request.URL.Path, duration)
        }
    }
}

中间件通信：

// 设置和获取中间件数据
func DataMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 设置数据
        c.Set("key", "value")
        
        c.Next()
        
        // 获取数据
        value, exists := c.Get("key")
        if exists {
            // 使用数据
        }
    }
}

// 响应修改中间件
func ResponseModifier() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Next()
        
        // 修改响应
        status := c.Writer.Status()
        if status >= 400 {
            c.JSON(status, gin.H{
                "error":   true,
                "message": c.Keys["error"],
            })
        }
    }
}

高级中间件示例：

// JWT 认证中间件
func JWTAuth() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        if token == "" {
            c.JSON(401, gin.H{"error": "No token provided"})
            c.Abort()
            return
        }

        claims, err := parseToken(token)
        if err != nil {
            c.JSON(401, gin.H{"error": "Invalid token"})
            c.Abort()
            return
        }

        c.Set("user_id", claims.UserID)
        c.Next()
    }
}

// 请求验证中间件
func ValidateRequest(schema interface{}) gin.HandlerFunc {
    return func(c *gin.Context) {
        if err := c.ShouldBindJSON(schema); err != nil {
            c.JSON(400, gin.H{"error": err.Error()})
            c.Abort()
            return
        }
        c.Set("validated_data", schema)
        c.Next()
    }
}

// 请求限制中间件
func RequestLimit(maxRequests int, duration time.Duration) gin.HandlerFunc {
    clients := make(map[string][]time.Time)
    mu := &sync.Mutex{}

    return func(c *gin.Context) {
        ip := c.ClientIP()
        now := time.Now()

        mu.Lock()
        defer mu.Unlock()

        // 清理过期的请求记录
        clients[ip] = filterOldRequests(clients[ip], now.Add(-duration))

        if len(clients[ip]) >= maxRequests {
            c.JSON(429, gin.H{"error": "Too many requests"})
            c.Abort()
            return
        }

        clients[ip] = append(clients[ip], now)
        c.Next()
    }
}

测试中间件：

func TestAuthMiddleware(t *testing.T) {
    // 创建测试路由
    r := gin.New()
    r.Use(Auth())
    r.GET("/test", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "success"})
    })

    // 创建测试请求
    w := httptest.NewRecorder()
    req, _ := http.NewRequest("GET", "/test", nil)
    
    // 不带 token 的请求
    r.ServeHTTP(w, req)
    assert.Equal(t, 401, w.Code)
    
    // 带有效 token 的请求
    w = httptest.NewRecorder()
    req.Header.Set("Authorization", "valid-token")
    r.ServeHTTP(w, req)
    assert.Equal(t, 200, w.Code)
}

中间件最佳实践：

// 中间件工厂
type MiddlewareConfig struct {
    EnableLogging bool
    LogLevel     string
    Timeout      time.Duration
}

func NewMiddleware(config MiddlewareConfig) gin.HandlerFunc {
    return func(c *gin.Context) {
        if config.EnableLogging {
            // 启用日志
        }
        
        // 设置超时
        ctx, cancel := context.WithTimeout(c.Request.Context(), config.Timeout)
        defer cancel()
        c.Request = c.Request.WithContext(ctx)
        
        done := make(chan bool)
        go func() {
            c.Next()
            done <- true
        }()
        
        select {
        case <-done:
            return
        case <-ctx.Done():
            c.JSON(504, gin.H{"error": "request timeout"})
            c.Abort()
        }
    }
}

使用这些中间件时，需要注意：

中间件的执行顺序很重要
合理使用 c.Next() 和 c.Abort()
避免在中间件中存储太多数据
注意性能影响
做好错误处理
保持中间件的独立性和可复用性

Gin 框架中间件详细介绍

悦读