gin-gonic的中间件使用非常简单，这里就不多说了，本文主要讲讲中间件的原理以及DEMO实现。
中间件是一个洋葱模型，中心为最终处理请求的 handler，称为 main handler，其他为 middleware handler 。每一个 middleware handle 可以分为两部分，随着 request 的流动，左边是入，右边为出，而分割点就是 next 。
next 的作用就是明确在这个地方进入到下一个 handler ，如果没有指定，默认是当前 handler 结束后进入下一个 handler。
由此看出各 middleware handle 都是先进后出的。
deml1：
package main
import (
"fmt"
)
type Context struct {
Handlers []func(*Context)
index int8
}
func (c *Context) Next() {
c.index++
c.Handlers[c.index](c)
}
func main() {
c := &Context{}
c.Handlers = make([]func(*Context), 0)
// 注册中间件
c.Handlers = append(c.Handlers, m1)
c.Handlers = append(c.Handlers, m2)
c.Handlers = append(c.Handlers, m3)
// 控制器函数
c.Handlers = append(c.Handlers, action)
// 启动
c.Handlers[0](c)
}
func action(c *Context) {
fmt.Println("main handler")
}
func m1(c *Context) {
fmt.Println("m1 start")
c.Next()
}
func m2(c *Context) {
fmt.Println("m2 start")
c.Next()
fmt.Println("m2 end")
}
func m3(c *Context) {
c.Next()
fmt.Println("m3 end")
}
m1, m2, m3 为 middleware handler，action 为 main handler。通过 Next 方法实现链路，以上程序输出：
m1 start
m2 start
main handler
m3 end
m2 end
符合预期，但是如果将 m2 的 c.Next() 去掉了，整个链路就断了，所以还要实现自动链路，思路就是只要链路被启动了，就自动往下运行，而不依靠 Next 方法。
修改 Next 方法：
func (c *Context) Next() {
c.index++
for c.index < int8(len(c.Handlers)) {
c.Handlers[c.index](c)
c.index++
}
}
这样，除了 m1 之外，其他几个去掉了 Next 方法，也能按预期运行了，现在需要将 m1 中的 Next 也去掉，则需要修改启动方式了。
// 启动
c.Handlers[0](c)
c.Next()
这样，所有的 middleware handler 都不用强依赖于 Next 也能按预期运行了。
有时候我们需要人为的中断请求，需要实现链路中断，参考gin中的实现方式，它定义了一个最大的 handler 索引最为判断依据，并且在注册 handler 的时候也做同样的判断。
于是，最终代码为：
package main
import (
"fmt"
"math"
)
const abortIndex int8 = math.MaxInt8 / 2
type Context struct {
Handlers []func(*Context)
index int8
}
func (c *Context) Next() {
c.index++
for c.index < int8(len(c.Handlers)) {
c.Handlers[c.index](c)
c.index++
}
}
func (c *Context) Abort() {
c.index = abortIndex
}
func main() {
c := &Context{}
c.Handlers = make([]func(*Context), 0)
// 注册中间件
c.Handlers = append(c.Handlers, m1)
c.Handlers = append(c.Handlers, m2)
c.Handlers = append(c.Handlers, m3)
// 控制器函数
c.Handlers = append(c.Handlers, action)
// 限制handler个数
if len(c.Handlers) >= int(abortIndex) {
panic("too many handlers")
}
// 启动
c.Handlers[0](c)
c.Next()
}
func action(c *Context) {
fmt.Println("main handler")
}
func m1(c *Context) {
fmt.Println("m1 start")
}
func m2(c *Context) {
fmt.Println("m2 start")
c.Abort()
c.Next()
fmt.Println("m2 end")
}
func m3(c *Context) {
c.Next()
fmt.Println("m3 end")
}
输出为：
m1 start
m2 start
m2 end
Abort方法实现了禁止向下传播，但是不会影响当前中间件的运行。