Golang Gin局部和全局中间件怎么使用

在Golang的Gin框架中，中间件（Middleware）是一种非常强大的工具，它允许我们在请求到达处理函数之前或之后执行一些操作。中间件可以用于日志记录、身份验证、错误处理、跨域资源共享（CORS）等场景。Gin框架支持全局中间件和局部中间件，本文将详细介绍如何使用这两种中间件。

1. 全局中间件

全局中间件是指在整个应用中都会生效的中间件。所有通过gin.Default()或gin.New()创建的Gin引擎实例都会应用这些中间件。

1.1 使用gin.Default()创建引擎

gin.Default()函数会自动添加两个全局中间件：Logger和Recovery。Logger用于记录请求日志，Recovery用于捕获panic并返回500错误。

package main

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

func main() {
    // 使用gin.Default()创建引擎，默认带有Logger和Recovery中间件
    r := gin.Default()

    r.GET("/", func(c *gin.Context) {
        c.String(200, "Hello, World!")
    })

    r.Run(":8080")
}

1.2 自定义全局中间件

我们可以通过Use()方法添加自定义的全局中间件。例如，添加一个简单的日志中间件：

package main

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

func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        t := time.Now()

        // 请求处理之前
        c.Next()

        // 请求处理之后
        latency := time.Since(t)
        log.Printf("Request: %s | Status: %d | Latency: %v", c.Request.URL.Path, c.Writer.Status(), latency)
    }
}

func main() {
    r := gin.New()

    // 添加自定义的全局中间件
    r.Use(Logger())

    r.GET("/", func(c *gin.Context) {
        c.String(200, "Hello, World!")
    })

    r.Run(":8080")
}

在这个例子中，Logger中间件会在每个请求处理前后记录日志。

2. 局部中间件

局部中间件是指仅在特定的路由或路由组中生效的中间件。我们可以通过Group()方法创建路由组，并在路由组中使用Use()方法添加局部中间件。

2.1 在路由组中使用局部中间件

package main

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

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 main() {
    r := gin.Default()

    // 创建一个路由组，并使用AuthMiddleware中间件
    authGroup := r.Group("/api")
    authGroup.Use(AuthMiddleware())
    {
        authGroup.GET("/data", func(c *gin.Context) {
            c.JSON(200, gin.H{"data": "This is protected data"})
        })
    }

    r.GET("/public", func(c *gin.Context) {
        c.String(200, "This is public data")
    })

    r.Run(":8080")
}

在这个例子中，AuthMiddleware中间件仅在/api路由组中生效。访问/api/data时，如果没有提供有效的Authorization头，请求将被拒绝。

2.2 在单个路由中使用局部中间件

我们也可以在单个路由中使用中间件：

package main

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

func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        t := time.Now()

        // 请求处理之前
        c.Next()

        // 请求处理之后
        latency := time.Since(t)
        log.Printf("Request: %s | Status: %d | Latency: %v", c.Request.URL.Path, c.Writer.Status(), latency)
    }
}

func main() {
    r := gin.Default()

    r.GET("/protected", Logger(), func(c *gin.Context) {
        c.String(200, "This is a protected route")
    })

    r.Run(":8080")
}

在这个例子中，Logger中间件仅在/protected路由中生效。

3. 中间件的执行顺序

中间件的执行顺序与它们被添加的顺序有关。全局中间件会先于局部中间件执行，而在同一层级中，中间件会按照它们被添加的顺序依次执行。

例如：

package main

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

func Middleware1() gin.HandlerFunc {
    return func(c *gin.Context) {
        log.Println("Middleware1: Before request")
        c.Next()
        log.Println("Middleware1: After request")
    }
}

func Middleware2() gin.HandlerFunc {
    return func(c *gin.Context) {
        log.Println("Middleware2: Before request")
        c.Next()
        log.Println("Middleware2: After request")
    }
}

func main() {
    r := gin.Default()

    r.Use(Middleware1())

    r.GET("/order", Middleware2(), func(c *gin.Context) {
        log.Println("Handler: Handling request")
        c.String(200, "Order processed")
    })

    r.Run(":8080")
}

输出结果将会是：

Middleware1: Before request
Middleware2: Before request
Handler: Handling request
Middleware2: After request
Middleware1: After request

4. 总结

Gin框架中的中间件提供了一种灵活的方式来处理请求和响应。全局中间件适用于整个应用，而局部中间件则适用于特定的路由或路由组。通过合理使用中间件，我们可以实现日志记录、身份验证、错误处理等功能，从而提高代码的可维护性和可扩展性。

在实际开发中，建议根据具体需求选择合适的中间件，并注意中间件的执行顺序，以确保它们能够按预期工作。