Gin 框架中间件详细介绍

get2002024-11-21 15:55
  1. 基本中间件结构：
go 复制代码 
// 基本中间件函数签名
func MiddlewareName() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 处理请求前的逻辑
        
        c.Next()  // 处理下一个中间件或处理函数
        
        // 处理请求后的逻辑
    }
}
  1. 常用中间件示例：
go 复制代码 
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()
    }
}
  1. 中间件的使用方式：
go 复制代码 
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")
}
  1. 带配置的中间件：
go 复制代码 
// 限流中间件
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(),
        }
    }
}
  1. 自定义上下文：
go 复制代码 
// 自定义上下文
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()
    }
}
  1. 链式中间件：
go 复制代码 
// 请求链路追踪
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)
        }
    }
}
  1. 中间件通信：
go 复制代码 
// 设置和获取中间件数据
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"],
            })
        }
    }
}
  1. 高级中间件示例：
go 复制代码 
// 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()
    }
}
  1. 测试中间件：
go 复制代码 
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)
}
  1. 中间件最佳实践：
go 复制代码 
// 中间件工厂
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()
  • 避免在中间件中存储太多数据
  • 注意性能影响
  • 做好错误处理
  • 保持中间件的独立性和可复用性
相关推荐
Clown953 小时前
go-zero(八) 中间件的使用
开发语言·中间件·golang
苹果酱05675 小时前
springcloud-网关路由gateway
java·开发语言·spring boot·mysql·中间件
隔着天花板看星星1 天前
Kafka-Consumer理论知识
大数据·分布式·中间件·kafka
隔着天花板看星星1 天前
Kafka-副本分配策略
大数据·分布式·中间件·kafka
wenyue11211 天前
Ease Monitor 会把基础层，中间件层的监控数据和服务的监控数据打通，从总体的视角提供监控分析
运维·中间件·监控
谷大羽2 天前
Kafka Stream实战教程
spring boot·后端·中间件·kafka·stream
隔着天花板看星星3 天前
Kafka-创建topic源码
大数据·分布式·中间件·kafka
0x派大星3 天前
【Golang】——Gin 框架中的 API 请求处理与 JSON 数据绑定
开发语言·后端·golang·go·json·gin
一水鉴天3 天前
智能工厂的设计软件 为了监管控一体化的全能Supervisor 的监督学习 之 序5 架构for认知系统 总述 （架构全图）
人工智能·学习·中间件·架构
热门推荐
01Docker 夺命连环 15 问02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04ICLR24大模型提示(1/11) | BadChain：大型语言模型的后门思维链提示05Coze扣子平台完整体验和实践（附国内和国际版对比）06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇08玄机平台应急响应—webshell查杀09RAG 实践- Ollama+RagFlow 部署本地知识库10【音视频 | opus】opus编解码库(opus-1.4)详细介绍以及使用——附带解码示例代码