中间件是一种可以拦截HTTP请求-响应生命周期的特殊函数，可以在请求处理过程中加入用户自己的钩子函数。Gin框架提供了一些默认的中间件，如Logger和Recovery，也允许用户自定义中间件。

使用中间件的好处有：

• 实现了逻辑的解耦和分离，每个中间件只负责各自的功能
• 可以实现一些通用的功能，如日志输出、错误处理、身份验证等
• 可以根据不同的路由或分组选择不同的中间件，实现灵活的控制

全局中间件：可以使用r.Use()方法注册一个全局中间件，它会对所有的请求生效。例如：

package main
import (
    "fmt"
    "net/http"
    "github.com/gin-gonic/gin"
)
func middleware1() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("这是中间件")
        c.Next()
    }
}
func main() {
    r := gin.Default()
    //注册一个全局中间件
    r.Use(middleware1())
    r.GET("/test", func(c *gin.Context) {
        fmt.Println("陈王昔时宴平乐，斗酒十千恣欢谑")
        c.JSON(http.StatusOK, gin.H{
            "msg": "主人何为言少钱，径须沽取对君酌",
        })
    })
    r.Run(":8080")
}

路由分组中间件：可以使用r.Group()方法创建一个路由分组，并在该分组上注册中间件，它只会对该分组下的请求生效。例如：

package main
import (
    "fmt"
    "github.com/gin-gonic/gin"
)
func middleware1() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("这是中间件")
        c.Next()
    }
}
func main() {
    r := gin.Default()
    v1 := r.Group("v1")
    v2 := r.Group("v2")
    //注册一个路由分组中间件
    v1.Use(middleware1())
    v1.GET("/test", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "msg": "这里是v1-test",
        })
    })
    v2.GET("/test", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "msg": "这里是v2-test",
        })
    })
    r.Run(":8080")
}

单个路由中间件：可以在注册单个路由时，传入多个处理函数，第一个处理函数就是中间件，它只会对该路由的请求生效。例如：

package main
import (
    "fmt"
    "net/http"
    "github.com/gin-gonic/gin"
)
func middleware1() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("这里是中间件")
        c.Next()
    }
}
func main() {
    r := gin.Default()
    //注册一个单个路由中间件
    r.GET("/", middleware1(), func(c *gin.Context) {
        fmt.Println("古来圣贤皆寂寞")
        c.JSON(http.StatusOK, "惟有饮者留其名")
    })
    r.Run(":8080")
}

在gin框架中，编写自定义的中间件函数的方法是定义一个返回值为gin.HandlerFunc类型的函数，并在该函数中接收一个*gin.Context类型的参数，用于获取请求和响应对象。例如：

// 定义一个自定义的日志记录中间件
func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 获取请求路径和方法
        path := c.Request.URL.Path
        method := c.Request.Method
        // 打印到控制台
        fmt.Printf("路径: %s, 方法: %s\n", path, method)
        // 调用下一个中间件或路由处理函数
        c.Next()
    }
}

Next()函数：

在gin框架中，next()是一个中间件函数中的一个函数，用于将控制权传递给下一个中间件函数或路由处理程序。当遇到c.Next()函数时，它取出所有的没被执行过的注册的函数都执行一遍，然后再回到本函数中。没遇到c.Next()函数将结束当前中间件程序。

package main
import (
    "fmt"
    "github.com/gin-gonic/gin"
)
func middleware1() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("中间件1开始")
        c.Next()
        fmt.Println("中间件1结束")
    }
}
func middleware2() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("中间件2开始")
        c.Next()
        fmt.Println("中间件2结束")
    }
}
func middleware3() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("中间件3开始")
        c.Next()
        fmt.Println("中间件3结束")
    }
}
func main() {
    r := gin.Default()
    r.Use(middleware1(), middleware2(), middleware3())
    r.GET("/", func(c *gin.Context) {
        fmt.Println("古来圣贤皆寂寞")
        c.JSON(200, gin.H{
            "data": "惟有饮者留其名",
        })
    })
    r.Run(":8080")
}

以上示例中，当中间件1中遇到c.Next(),将控制权传递给中间件2，再次遇到c.Next()函数将控制权传递给中间3，中间件3将控制权传递给路由处理程序；然后再回到中间件3，执行c.Next()后的程序，中间件3结束，后面一次是中间件2、中间件1结束。

备注中间件1中的c.Next()函数,程序执行结果如下：

func middleware1() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("中间件1开始")
        // c.Next()
        fmt.Println("中间件1结束")
    }
}

中间件1中没使用c.Next()函数，将直接执行完毕本函数，再依次执行注册的中间件函数。

Abort()函数：

在gin框架中，abort()是Context对象的一个方法，用于立即终止当前请求并返回一个指定的HTTP状态码和错误信息。

func middleware2() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("中间件2开始")
        if 3 < 4 {
            c.Abort()
        }
        c.Next()
        fmt.Println("中间件2结束")
    }
}

在中间件2中使用Abort()函数，执行结果如下：

中间件1开始 
中间件2开始 
中间件2结束 
中间件1结束

这个方法函数常用于处理一些非法请求或者权限校验失败的场景。例如：

func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 检查用户是否登录
        if !IsLoggedIn(c) {
            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "未登录"})
            return
        }
        // 认证通过，继续执行后续的中间件和处理函数
        c.Next()
    }
}

在这个示例中，AuthMiddleware中间件会检查用户是否已登录，如果未登录，则使用abort()方法立即返回一个状态码为401的错误响应，否则继续执行后续的中间件和处理函数。

内置BasicAuth中间件

BasicAuth中间件是一个用于基本认证的中间件，它会对请求进行基本认证，如果认证失败，则返回401 Unauthorized错误响应。

package main

import (
    "net/http"

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

var map_data map[string]interface{} = map[string]interface{}{
    "xiaoming": gin.H{"age": 18, "addr": "xxx"},
    "xiaohong": gin.H{"age": 20, "addr": "xxxx"},
}

func main() {
    r := gin.Default()
    // gin.Accounts是gin框架中用于存储用户账号和密码的一种数据结构。
    // 它是一个map[string]string类型的变量，其中键表示用户名，值表示密码。
    // 它通常用于BasicAuth中间件中，用于验证用户的用户名和密码。
    r.GET("/", gin.BasicAuth(gin.Accounts{
        "xiaotu": "123456",
    }), func(c *gin.Context) {
        user_name := c.Query("user_name")
        data, ok := map_data[user_name]
        if ok {
            c.JSON(http.StatusOK, gin.H{
                "user": user_name,
                "data": data,
            })
        } else {
            c.JSON(http.StatusNotFound, gin.H{
                "user": user_name,
                "data": "没有数据",
            })
        }
    })
    r.Run(":8080")
}

使用账户xiaotu和密码123456登录，进行授权认证通过，访问路径中user_name参数为xiaoming和xiaohong的时候，获取对应的信息。

访问路径中user_name参数为xiaohong111的时候，没有对应的数据。

在这个示例中，我们使用了BasicAuth中间件，只有在提供正确的用户名和密码时，才能访问该接口。在这里，我们使用了一个固定的用户名和密码。