Gee教程5.中间件

鉴权认证、日志记录等这些保障和支持系统业务属于全系统的业务，和具体的系统业务没有关联，对于系统中的很多业务都适用。

因此，在业务开发过程中，为了更好的梳理系统架构，可以将上述描述所涉及的一些通用业务单独抽离并进行开发，然后以插件化的形式进行对接。这种方式既保证了系统功能的完整，同时又有效地将具体业务和系统功能进行解耦，还可以达到灵活配置的目的。

这种通用业务独立开发并灵活配置使用的组件，一般称之为"中间件"。其就相当于在请求和具体的业务逻辑处理之间增加某些操作，这种以额外添加的方式不会影响编码效率，也不会侵入到框架中。

每个用户都有自己的业务，Web框架不可能实现所有的功能。因此，框架需要有一个插口，允许用户自己定义通用功能，嵌入到框架中，仿佛这个功能是框架原生支持的一样。这个也就是我们所说的中间件。

通俗点理解，中间件就是个函数。比如前缀是/admin来访问的都需要进行鉴权认证，而Web框架又没有实现这个功能。

这时可能想到直接在该路由的处理函数加上这个功能就行啦。但是要是有很多前缀是/admin的路由，那就要写很多很多，这是很繁琐的。

中间件的使用

那我们就想有这种效果，这种就写的很舒服了，gin框架就是这样使用的。

//鉴权中间件
func AuthMiddleWare() gee.HandlerFunc {
	........
}
 
func main() {
	r := gee.New()
	v2 := r.Group("/admin")	
	v2.Use(AuthMiddleWare()) //该路由组使用鉴权中间件，也只有该组使用这个中间件
	v2.GET("/home", func(c *gee.Context) {
        //AuthMiddleWare()
		c.JSON(http.StatusOK, gin.H{
			"msg": "home路由",
		})
	})
	v2.GET("/ok", func(c *gee.Context) {
        //AuthMiddleWare()
		c.JSON(http.StatusOK, gin.H{
			"msg": "ok路由",
		})
	})
}

中间件的设计

前面说了中间件是个函数，那可以设置成映射的 Handler 一致，处理的输入是Context对象。

type HandlerFunc func(*Context)

一个路由组可以会使用多个中间件的，上一节中已在路由组的结构中添加了中间件数组。那来实现下添加中间件方法Use。该方法可以一次添加多个中间件。

RouterGroup struct {
	prefix      string
	middlewares []HandlerFunc // support middleware
	parent      *RouterGroup  // support nesting
	engine      *Engine       // all groups share a Engine instance
}

func (group *RouterGroup) Use(middlewares ...HandlerFunc) {
	group.middlewares = append(group.middlewares, middlewares...)
}

简单想法：一条直线处理

我们想的简单的版本，前后添加了中间件A,中间件B。那处理的流程就是：中间件A -----> 中间件B -----> 路由处理函数。

回到我们的执行路由处理函数部分，那么ServeHTTP就需要改动下。

//之前的
//func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
//	c := newContext(w, req)
//	engine.router.handle(c)
//}

//需要执行中间件的做法
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	c := newContext(w, req)
	for _, group := range engine.groups {
		if strings.HasPrefix(req.URL.Path, group.prefix) {
			group.middlewares(c)    //执行中间件
		}
	}

	engine.router.handle(c)
}

这种实现起来是很简单，但却不实用的。就像是要鉴权认证，假如认证失败后，那肯定是不执行路由处理函数的，而这个做法却是继续执行的。

还有有些中间件想在路由处理函数执行后做一些操作，例如计算响应时长之类的。 那就要等路由处理函数执行后才可以计算，当前实现的做法是不妥的，不能实现这样功能的。所以需要继续改善。

我们想要的中间件是支持用户在请求被处理的前后，做一些额外的操作。

改善

现在来看一个中间件，日志中间件。

假如我们要计算响应时长，那就是要等路由Handler处理完之后才能执行第八行代码。所以需要做些操作。

那在第六行中,c.Next()表示执行其他的中间件或用户的Handler。

等执行完其他中间件和用户的Handler后，再执行第八行代码，这样就可以符合我们想记录响应时长的要求了。

func Logger() HandlerFunc {
	return func(c *Context) {
		// Start timer
		t := time.Now()
		// Process request
		c.Next()
		// Calculate resolution time
		log.Printf("[%d] %s in %v", c.StatusCode, c.Req.RequestURI, time.Since(t))
	}
}

//鉴权中间件
func AuthMiddleWare() HandlerFunc {
	........
}
func main() {
	r := gee.New()    
    r.Use(Logger())
	v2 := r.Group("/admin")	
	v2.Use(AuthMiddleWare()) //该路由组使用鉴权中间件，也只有该组使用这个中间件
	v2.GET("/home", func(c *gee.Context) {
		c.JSON(http.StatusOK, gin.H{
			"msg": "home路由",
		})
	})

}

 那么重点就是在c.Next()中了。c.Next()可以执行中间件，那说明Context保存了该中间件。所以，Context结构体添加了中间件切片midHandlers和index。

type Context struct {
	// origin objects
	Writer http.ResponseWriter
	Req    *http.Request
	// request info
	Path   string
	Method string
	Params map[string]string
	// response info
	StatusCode int
	// middleware
	midHandlers []HandlerFunc        //这节新添加的
	index    int8        //这节新添加的
}    

func newContext(w http.ResponseWriter, req *http.Request) *Context {
	return &Context{
		Wrtier: w,
		Req:    req,
		Path:   req.URL.Path,
		Method: req.Method,
		index:  -1, //这节新添加的
	}
}

func (c *Context) Next() {
	c.index++

	for c.index < int8(len(c.midHandlers)) {
		c.midHandlers[c.index](c) //执行中间件
		c.index++
	}
}

index是记录当前执行到第几个中间件，当在中间件中调用Next方法时，控制权交给了下一个中间件，直到调用到最后一个中间件，然后再从后往前，调用每个中间件在Next方法之后定义的部分。

如果我们将用户在映射路由时定义的Handler添加到c.handlers列表中，结果会怎么样呢？

func A(c *Context) {
    part1        //可以是记录开始时间
    c.Next()
    part2        //可以是记录整个响应时长
}
func B(c *Context) {
    part3
    c.Next()
    part4
}

假设我们应用了中间件 A 和 B，和路由映射的 Handler。那么c.handlers是这样的：[A, B, Handler]，c.index初始化为-1。

先执行中间件A，那就是先执行到part1。之后到c.Next()，这时候就到执行c.handlers中的下一个，即是中间件B，那就是执行part3。之后执行c.Next()，这时就执行到路由Hander,跟着就到了part4。part4结束后，即是中间件中的c.Next()结束了，最终执行part2.

index是怎么变化的要到后面才好说明白。

最终的顺序是part1 -> part3 -> Handler -> part 4 -> part2。恰恰满足了我们对中间件的要求。

接着就看回到ServeHTTP方法。

func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	// c := newContext(w, req)
	// engine.router.handle(c)

	var middlewares []HandlerFunc
	for _, group := range engine.gorups {
		if strings.HasPrefix(req.URL.Path, group.prefix) {
			middlewares = append(middlewares, group.middlewares...) //添加该路由组的中间件
		}
	}
	c := newContext(w, req)
	c.midHandlers = middlewares    //路由组中间件都赋值给Context结构体的midHandlers 
	engine.router.handle(c)
}

那之后肯定是在engine.router.handle(c)中有些变化的了。

最后的c.Next()是很重要的，这样操作后，所有的中间件和路由Handler都统一在Next()中执行的了。

这里可以把之前例子里的index的疑惑讲明白了。c.index默认初始化是-1的，这里执行C.Next(),c.index就变成0了，就可以执行c.handler[0],即是中间件A。

func (r *router) handle(c *Context) {
	n, params := r.getRoute(c.Method, c.Path)
	if n != nil {
		key := c.Method + "-" + n.path
		c.Params = params
		c.midHandlers = append(c.midHandlers, r.handers[key]) //添加路由Handler到midHandlers中
	} else {
		c.midHandlers = append(c.midHandlers, func(c *Context) {
			c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
		})
	}
	c.Next() //从这里开始执行第一个中间件，要是没有中间件就直接执行路由Handler


    //上一节的做法
	//n, params := r.getRoute(c.Method, c.Path)
	// if n != nil {
	// 	c.Params = params
	// 	// key := c.Method + "-" + c.Path
	// 	key := c.Method + "-" + n.path
	// 	fmt.Println(key)
	// 	r.handers[key](c)
	// } else {
	// 	c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
	// }
}

 说完了c.Next()后，还有c.Abort()方法。

在进行鉴权认证不通过后，后面的中间件和路由Handler也就不需要执行的了。

在c.Next()中是通过c.index来进行判断执行哪个中间件的。首先我们定义AbortIndex常量，主要是用于控制框架处理请求链路的长度，即是中间件和路由Handler总个数。这时候设置c.index=AbortIndex,那么c.Next()就不会执行中间件了。那么我们在之前使用Use添加中间件的时候，就需要判断中间件个数是否超过了最大个数，这里就不展示了。

const AbortIndex = math.MaxInt8 >> 1

func (c *Context) Abort() {
	c.index = AbortIndex
}

测试

场景：/admin的使用鉴权认证中间件，全局的使用日志中间件。

鉴权失败的话，调用c.Abort()

func authMiddleWare() gee.HandlerFunc {
	return func(c *gee.Context) {
		fmt.Println("start 鉴权中间件")
		token := c.Req.Header.Get("token")
		if token == "" || token != "123" {
			c.JSON(http.StatusUnauthorized, gee.H{"message": "身份验证失败"})
			c.Abort()
			//return //不使用return的话，后面的fmt.Println("hello")会执行，使用return的话，后面的不会执行
		} else {
			fmt.Println("鉴权成功")
		}
		//使用Abort()后要是不使用return,打印hello还是会执行的
		//fmt.Println("hello")
	}
}

func main() {
	r := gee.New()
	r.Use(gee.Logger())
	r.GET("/home", func(c *gee.Context) {
		c.HTML(http.StatusOK, "<h1>Index home</h1>")
	})

	v1 := r.Group("/admin")
	v1.Use(authMiddleWare())
	{
		v1.GET("/myname", func(c *gee.Context) {
			c.String(http.StatusOK, "Hello li")
		})
	}

	r.Run("localhost:10000")
}

结果

完整代码：https://github.com/liwook/Go-projects/tree/main/gee-web/5-Middlewares