一、介绍:

使用 BasicAuth 中间件: https://gin-gonic.com/zh-cn/docs/examples/using-basicauth-middleware/

在中间件中使用 Goroutine: https://gin-gonic.com/zh-cn/docs/examples/goroutines-inside-a-middleware/

1. 什么是中间件:

• 开发者自定义的钩子(Hook)函数;
• 类似python中的装饰器;

2. 中间件的作用

• 中间件适合处理一些公共的业务逻辑，比如登录认证、权限校验、数据分页、记录日志、耗时统计等;
• 需要对某一类函数进行通用的前置或者后置处理;

3. 使用场景

• 逻辑执行之前
  • token等认证
  • 权限校验
  • 限流
  • 数据过滤
  • 白名单
  • …
• 逻辑执行之后
  • 数据过滤，比如敏感词等
  • 统一的响应头等
  • …

二、中间件的使用:

1. 使用中间件:

router := gin.New()

router.Use(gin.Logger())
router.Use(gin.Recovery())
punctuation">.Default()

router.Get("/login",xxx)

router.Get("/user_list",xxx)
router.Get("/news_list",xxx)
1
2
3
4
5
6

加入user_list和news_list需要在登陆后才可以访问，login不要登录认证就可访问，
这时候我们需要一个token认证的中间件，那这个中间件Use的位置会有影响，如下：

router := gin.Default()

router.Get("/login",xxx)

router.User(MiddleWare())

router.Get("/user_list",xxx)
router.Get("/news_list",xxx)

// Use不能放在login的前面，不然也会对login进行拦截认证
1
2
3
4
5
6
7
8
9
10

注意：Use不能放在login的前面，不然也会对login进行拦截认证

3. 中间件执行顺序示例:

func MiddlewareA() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        fmt.Println("MiddlewareA before request")
        // before request
        ctx.Next()
        // after request
        fmt.Println("MiddlewareA after request")
    }
}

func MiddlewareB() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        fmt.Println("MiddlewareB before request")
        // before request
        ctx.Next()
        // after request
        fmt.Println("MiddlewareB after request")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

三、gin内置中间件:

四、自定义中间件:

1. 自定义中间件的两种方式:

// 自定义中间件第1种定义方式
func MiddleWare1(ctx *gin.Context)  {
    fmt.Println("这是自定义中间件1")
}

// 自定义中间件第2种定义方式
func MiddleWare2() gin.HandlerFunc  {
    return func(ctx *gin.Context) {
        fmt.Println("这是自定义中间件2")
    }
}


router := gin.New()

router.Use(MiddleWare1)      // 需要加括号
router.Use(MiddleWare2())    // 不需要加括号，当成参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

五、中间件中的Next和Abort:

1. Next:

在定义的众多中间件，会形成一条中间件链，而通过 Next 函数来对后面的中间件进行执行
特点:

• 当遇到ctx.Next()函数时 它取出所有的没被执行过的注册的函数都执⾏⼀遍，然后再回到本函数中，有点类似递归函数
• Next 函数是在请求前执行，而 Next 函数后是在请求后执行。
• 可以用在token校验，把用户id存起来供给功能性函数使用

2.Abort:

ctx.Abort()方法的作用 终止调用整个链条
比如：token认证没有通过，不能直接使用return返回，而是使用Abort来终止

3. 中间件执行顺序示例

func MiddleWare1(ctx *gin.Context)  {

    fmt.Println("这是自定义中间件1--开始")
    ctx.Next()
    fmt.Println("这是自定义中间件1--结束")
}

func MiddleWare2() gin.HandlerFunc {

    return func(ctx *gin.Context) {
        fmt.Println("这是自定义中间件2--开始")

        if 3 < 4{   // 满足条件
            ctx.Abort()
        }
        ctx.Next()
        fmt.Println("这是自定义中间件2--结束")
    }
}

func MiddleWare3(ctx *gin.Context)  {
    fmt.Println("这是自定义中间件3--开始")
    ctx.Next()
    fmt.Println("这是自定义中间件3--结束")
}


router := gin.Default()

router.Use(Middleware1,Middleware2(),Middleware3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

六、在全局、路由组、局部的使用：

1. 全局:

2. 路由组:

3.局部:

 func Middle1Ware() gin.HandlerFunc{
    return func(c *gin.Context) {
        fmt.Println("我是自定义中间件第2种定义方式---请求之前")
        //在gin上下文中定义一个变量
        c.Set("example", "CustomRouterMiddle2")
        //请求之前
        c.Next()
         //请求之后
        fmt.Println("我是自定义中间件第2种定义方式---请求之后")
    }
}

// 路由映射时可以传多个HandlerFunc
router := gin.Default()

router.GET("/hello",Middle1Ware(),Hello)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

七、案例: 内置BaseAuth中间件:

1. BasicAuth中间件的使用:

// 局部使用中间价
chap05.GET("/basic",gin.BasicAuth(gin.Accounts{
        "zs":"123456",
        "ls":"123",
        "ww":"1234",
    }),BasicAuthTest)


// 私有数据
var map_data map[string]interface{} = map[string]interface{}{
    "zs":gin.H{"age":18,"addr":"zs-xx"},
    "ls":gin.H{"age":19,"addr":"ls-xx"},
    "ww":gin.H{"age":20,"addr":"ww-xx"},
}


// 获取私有数据。如果没有权限则获取不到
func BasicAuthTest(ctx *gin.Context)  {

    user_name := ctx.Query("user_name")
    data ,ok := map_data[user_name]

    if ok{
        ctx.JSON(http.StatusOK,gin.H{"user_name":user_name,"data":data})
    }else {
        ctx.JSON(http.StatusOK,gin.H{"user_name":user_name,"data":"没有权限"})
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

一文读懂HTTP Basic身份认证:https://juejin.im/entry/6844903586405564430

执行逻辑：

登录页面(没有中间件) --> 会设置session --> 其他路由回去session的key --> 获取对应的数据
1

2. WrapF: 中间件

gin.WrapF(IndexHandler)

func IndexHandler(w http.ResponseWriter, r *http.Request)  {
    ...
}
1
2
3
4
5

3. WrapH和WrapF的区别

需要自己去定义struct实现这个Handler接口

type TestStruct struct {}

func (test *TestStruct) TestH(w http.ResponseWriter, r *http.Request) {
    ...
}
1
2
3
4
5