在Gin的整个实现中，中间件可谓是Gin的精髓。一个个中间件组成一条中间件链，对HTTP Request请求进行拦截处理，实现了代码的解耦和分离，并且中间件之间相互不用感知到，每个中间件只需要处理自己需要处理的事情即可。今天我们就通过这篇文章，详细的介绍Gin中间的使用和原理。

通过这篇文章你可以学到：

  1. Gin中间件入门
  2. 如何使用Gin的默认中间件
  3. 中间件实现HTTP Basic Authorization
  4. 基于分组路由的中间件控制
  5. 自定义一个统计耗时的中间件
  6. 中间件的设计模式-责任链
  7. 自己实现一个责任链模式
  8. 中间件Next方法的实现原理
  9. Gin中间件源码分析
  10. Gin中间件面试要点

Gin默认中间件

在Gin中，我们可以通过Gin提供的默认函数，来构建一个自带默认中间件的*Engine。

  1. r := gin.Default()

Default函数会默认绑定两个已经准备好的中间件，它们就是Logger 和 Recovery，帮助我们打印日志输出和painc处理。

  1. func Default() *Engine {
  2.     debugPrintWARNINGDefault()
  3.     engine := New()
  4.     engine.Use(Logger(), Recovery())
  5.     return engine
  6. }

从中我们可以看到，Gin的中间件是通过Use方法设置的，它接收一个可变参数，所以我们同时可以设置多个中间件。

  1. func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes

到了这里其实我们应该更加明白了，一个Gin的中间件，其实就是Gin定义的一个HandlerFunc,而它在我们Gin中经常使用，比如：

  1. r.GET("/", func(c *gin.Context) {
  2.         fmt.Println("首页")
  3.         c.JSON(200, "")
  4.     })

后面的func(c *gin.Context)这部分其实就是一个HandlerFunc。

中间件实现HTTP Basic Authorization

HTTP Basic Authorization 是HTTP常用的认证方案，它通过Authorization 请求消息头含有服务器用于验证用户代理身份的凭证，格式为：

  1. Authorization: Basic <credentials>

如果认证不成功，服务器返回401 Unauthorized 状态码以及WWW-Authenticate 消息头，让客户端输入用户名和密码进一步认证。
在Gin中，为我们提供了gin.BasicAuth帮我们生成基本认证的中间件，方便我们的开发。

  1.     r := gin.Default()
  3.     r.Use(gin.BasicAuth(gin.Accounts{
  4.         "admin": "123456",
  5.     }))
  7.     r.GET("/", func(c *gin.Context) {
  8.         c.JSON(200, "首页")
  9.     })
  11.     r.Run(":8080")

我们添加一个用户名为admin,密码是123456的账户，用于HTTP 基本认证。现在我们运行启动，访问http://localhost:8080/，这时候只有我们输入正确的用户名和密码，才能看到首页，否则是看不到的，这样我们就达到了授权的目的,就是这么简单。

针对特定URL的Basic Authorization

其实在实际的项目开发中，我们基本上不太可能对所有的URL都进行认证的，一般只有一些需要认证访问的数据才需要认证，比如网站的后台，那么这时候我们就可以用分组路由来处理。

  1. func main() {
  2.     r := gin.Default()
  4.     r.GET("/", func(c *gin.Context) {
  5.         c.JSON(200, "首页")
  6.     })
  8.     adminGroup := r.Group("/admin")
  9.     adminGroup.Use(gin.BasicAuth(gin.Accounts{
  10.         "admin": "123456",
  11.     }))
  13.     adminGroup.GET("/index", func(c *gin.Context) {
  14.         c.JSON(200, "后台首页")
  15.     })
  17.     r.Run(":8080")
  18. }

现在我们运行访问/首页是可以正常显示的，但是我们访问/admin/index会提示输入密码，其实所有/admin/*下的URL都会让输入密码才能访问，这就是我们分组路由的好处，我们通过把中间件加到/admin这个分组路由上，就可以达到我们的目的。
通过分组路由的控制，我们可以比较灵活的设置HTTP认证，粒度可以自己随意控制。

自定义中间件

我们已经知道，Gin的中间件其实就是一个HandlerFunc,那么只要我们自己实现一个HandlerFunc，就可以自定义一个自己的中间件。现在我们以统计每次请求的执行时间为例，来演示如何自定义一个中间件。

  1. func costTime() gin.HandlerFunc {
  2.     return func(c *gin.Context) {
  3.         //请求前获取当前时间
  4.         nowTime := time.Now()
  6.         //请求处理
  7.         c.Next()
  9.         //处理后获取消耗时间
  10.         costTime := time.Since(nowTime)
  11.         url := c.Request.URL.String()
  12.         fmt.Printf("the request URL %s cost %v\n", url, costTime)
  13.     }
  14. }

以上我们就实现了一个Gin中间件，比较简单，而且有注释加以说明，这里要注意的是c.Next方法，这个是执行后续中间件请求处理的意思（含没有执行的中间件和我们定义的GET方法处理），这样我们才能获取执行的耗时。也就是在c.Next方法前后分别记录时间，就可以得出耗时。
有了自定义的中间件，我们就可以这么使用。

  1. func main() {
  2.     r := gin.New()
  4.     r.Use(costTime())
  6.     r.GET("/", func(c *gin.Context) {
  7.         c.JSON(200, "首页")
  8.     })
  10.     r.Run(":8080")
  11. }

现在启动程序，在浏览器里打开就可以看到如下日志信息了。

  1. the request URL / cost 26.533µs

通过自定义中间件,我们可以很方便的拦截请求，来做一些我们需要做的事情，比如日志记录、授权校验、各种过滤等等。

责任链模式

在讲Gin的中间件的原理之前，我们先了解下设计模式中的责任链模式。顾名思义，责任链模式就是为请求创建一个对象链，对象链上的每个对象都可以依次对请求进行处理，并把处理过的请求传递给下一个对象。
看上图比较形象，从左到右横向是一个请求，在请求之上的是一个个对象（1-5），这5个对象就组成了处理责任链，依次对请求进行处理，并且处理完之后，把请求传递给下一个对象处理,生动描述详见下图：