编辑“︁Gin自定义中间件”︁（章节）

= Gin自定义中间件 =

== 介绍 ==  
'''Gin中间件'''是Gin框架的核心功能之一，允许开发者在HTTP请求到达路由处理函数之前或之后执行特定逻辑。自定义中间件则是指开发者根据业务需求编写的中间件，用于实现认证、日志记录、错误处理等通用功能。通过中间件，可以实现代码复用和逻辑解耦。

中间件的本质是一个函数，其签名如下：  
<syntaxhighlight lang="go">
func(c *gin.Context)
</syntaxhighlight>  
或返回该函数的闭包（如需要配置参数时）。  

== 基本语法 ==  
以下是一个最简单的自定义中间件示例：  
<syntaxhighlight lang="go">
package main

import "github.com/gin-gonic/gin"

// 自定义中间件
func MyMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 请求前逻辑
        c.Next() // 调用后续中间件或路由处理函数
        // 请求后逻辑
    }
}

func main() {
    r := gin.Default()
    r.Use(MyMiddleware()) // 全局注册中间件
    r.GET("/", func(c *gin.Context) {
        c.String(200, "Hello, Gin!")
    })
    r.Run(":8080")
}
</syntaxhighlight>

=== 关键点说明 ===  
* '''c.Next()'''：执行后续中间件或路由处理函数，之后会回到当前中间件继续执行剩余逻辑。  
* '''c.Abort()'''：终止后续中间件和路由的执行。  

== 实际案例 ==  

=== 案例1：请求耗时统计 ===  
<syntaxhighlight lang="go">
func RequestTimer() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        c.Next()
        duration := time.Since(start)
        log.Printf("Request to %s took %v", c.Request.URL.Path, duration)
    }
}
</syntaxhighlight>

=== 案例2：API密钥认证 ===  
<syntaxhighlight lang="go">
func APIKeyAuth(validKey string) gin.HandlerFunc {
    return func(c *gin.Context) {
        key := c.GetHeader("X-API-Key")
        if key != validKey {
            c.AbortWithStatusJSON(401, gin.H{"error": "Invalid API key"})
            return
        }
        c.Next()
    }
}
</syntaxhighlight>

== 执行流程 ==  
以下Mermaid图展示了中间件的执行顺序：  
<mermaid>
sequenceDiagram
    participant Client
    participant Middleware1
    participant Middleware2
    participant Handler
    Client->>Middleware1: 请求进入
    Middleware1->>Middleware2: c.Next()
    Middleware2->>Handler: c.Next()
    Handler-->>Middleware2: 返回响应
    Middleware2-->>Middleware1: 返回响应
    Middleware1-->>Client: 返回响应
</mermaid>

== 高级用法 ==  

=== 上下文数据传递 ===  
中间件可通过<code>c.Set()</code>和<code>c.Get()</code>在请求链中共享数据：  
<syntaxhighlight lang="go">
func UserInjector() gin.HandlerFunc {
    return func(c *gin.Context) {
        user := getUserFromToken(c)
        c.Set("currentUser", user)
        c.Next()
    }
}

// 路由处理函数中获取数据
func getUser(c *gin.Context) {
    user, exists := c.Get("currentUser")
    if !exists {
        c.AbortWithStatus(404)
        return
    }
    c.JSON(200, user)
}
</syntaxhighlight>

=== 错误处理中间件 ===  
统一捕获panic并返回标准化错误：  
<syntaxhighlight lang="go">
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.Next()
    }
}
</syntaxhighlight>

== 最佳实践 ==  
1. '''单一职责'''：每个中间件只处理一个具体任务  
2. '''避免阻塞'''：耗时应通过协程异步处理  
3. '''合理排序'''：中间件按依赖顺序注册（如认证中间件需在业务逻辑前执行）  

== 数学公式（可选） ==  
若需计算中间件性能影响，可用以下公式估算总延迟：  
<math>
T_{total} = T_{mw1} + T_{mw2} + ... + T_{handler}
</math>  

== 总结 ==  
Gin自定义中间件是实现横切关注点（Cross-Cutting Concerns）的理想方式。通过本文的示例和解释，开发者应能掌握从基础到高级的中间件编写技巧，并应用于实际项目中。

[[Category:后端框架]]
[[Category:Gin]]
[[Category:Gin中间件]]