Golang Web入门(3):若何优雅的设计中间件

摘要

上一篇文章中,我们已经可以实现一个性能较高,且支持RESTful气概的路由了。然则,在Web应用的开发中,我们还需要一些可以被扩展的功效。

因此,在设计框架的历程中,应该留出可以扩展的空间,好比:日志纪录、故障恢复等功效,若是我们把这些营业逻辑全都塞进Controller/Handler中,会显得代码稀奇的冗余,杂乱。

以是在这篇文章中,我们来探讨若何更优雅的设计这些中间件。

1 耦合的实现方式

好比我们要实现一个日志纪录的功效,我们可以用这种简朴粗暴的方式:

package main

import (
	"fmt"
	"net/http"
	"time"
)

func helloWorldHandler(w http.ResponseWriter, r *http.Request) {
	record(r.URL.Path)
	fmt.Fprintf(w, "Hello World !")
}

func main() {
	http.HandleFunc("/hello", helloWorldHandler)
	http.ListenAndServe(":8000", nil)
}

func record(path string)  {
	fmt.Println(time.Now().Format("3:04:05 PM Mon Jan") + " " + path)
}

若是这样做的话,确实是实现了我们的目的,纪录了接见的日志。

然则,这样一点都不优雅。

每一个Handler内部都需要挪用record函数,然后再把需要纪录的path作为参数传进record函数中。

若是这样做,不管我们需要添加什么样的分外功效,都必须得把这个分外的功效和我们的营业逻辑牢牢地绑定到一起,不能实现扩展功效与营业逻辑间的解耦。

2 将纪录与实现解耦

既然在上面的实现中,纪录日志和营业实现完全的耦合在了一起,那么我们能不能把他们的营业实现解耦开来呢?

来看这段代码:

func record(w http.ResponseWriter, r *http.Request)  {
	path := r.URL.Path
	method := r.Method
	fmt.Println(time.Now().Format("3:04:05 PM Mon Jan") + " " + method + " " + path)
}

func helloWorldHandler(w http.ResponseWriter, r *http.Request) {
	record(w ,r)
	fmt.Fprintf(w, "Hello World !")
}

在这里,我们已经把营业实现和日志纪录的耦合给解开了一部门。

我们只需要在营业代码中,挪用record(w,r)函数,把请求的内容作为参数传进record函数中,然后在record这个方式内纪录日志。这个时刻,我们可以在方式内部随便的处置请求,保留如请求路径、请求方式等数据。而这个历程,对营业实现是透明的

这样做的话,我们只需要在处置营业逻辑的Handler中挪用函数,然后把参数传进去。而这个函数的详细实现,则是与营业逻辑无关的。

那么,有没有设施可以把营业逻辑和扩展功效完全离开,让营业代码里只有营业代码,使代码变得加倍整齐呢?我们接着往下看。

3 设计中间件

我们在上一篇文章内里,剖析了httprouter这个包的实现。以是我们直接对他着手,修改他的代码,使得这个路由具有扩展性。

3.1 效果

在此之前,我们来看看效果:

package main

import (
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/julienschmidt/httprouter"
)

func Hello(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
	fmt.Fprint(w, "Hello World!\n")
}

func record(w http.ResponseWriter, r *http.Request){
	path := r.URL.Path
	method := r.Method
	fmt.Println(time.Now().Format("3:04:05 PM Mon Jan") + " " + method + " " + path)
}


func main() {
	router := httprouter.New()
	router.AddBeforeHandle(record)
	router.GET("/hello", Hello)
	log.Fatal(http.ListenAndServe(":8080", router))
}

这部门的代码和上一篇的险些完全一样。也是建立一个路由,将/hello这个路径和Hello这个处置器绑定在GET的这颗前缀树中,然后最先监听8080端口。

这里对照主要的是main方式内里的第二行:

router.AddBeforeHandle(record)

从方式名可以看出,这个方式是在Handle之前增添了一个处置历程。

再看看参数,就是我们上面提到的纪录接见日志的方式,这个方式纪录了请求的URL,请求的方式,以及时间。

而在我们的Hello(w http.ResponseWriter, r *http.Request, _ httprouter.Params)函数中,已经不包罗任何其他的营业逻辑了。

此时,这个Handler专注于处置营业逻辑,至于其余,交给其余函数去实现。这样,就实现了完全的解耦

下面我们来看看详细的实现历程:

3.2 详细实现

先来看看AddBeforeHandle这个方式:

func (r *Router) AddBeforeHandle(fn func(w http.ResponseWriter, req *http.Request))  {
	r.beforeHandler = fn
}

这个方式很简朴,也就是吸收一个处置器类型的参数,然后赋值给Router中的字段beforeHandler

这个名为beforeHandler字段也是我们新增在Router中的,相信你也能看得出来了,所谓的AddBeforeHandle方式,就是把我们传进去的处置函数,保留在Router中,在需要的时刻挪用他。

那么我们来看看,什么时刻会挪用这个方式。下面列出的这个方式,在上一篇文章有提到,是关于httprouter是若何处置路由的:

func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	...
	if root := r.trees[req.Method]; root != nil {
		if handle, ps, tsr := root.getValue(path, r.getParams); handle != nil {
		    if r.beforeHandler != nil{
				r.beforeHandler(w, req)
			}
			if ps != nil {
				handle(w, req, *ps)
				r.putParams(ps)
			} else {
				handle(w, req, nil)
			}
			return
		} 
	}
    ...
}

注重看,router在找到了Handler,准备执行之前,我们添加了这么几行:

if r.beforeHandler != nil{
	r.beforeHandler(w, req)
}

也就是说,若是我们之前挪用了AddBeforeHandle方式,给beforeHandler这个字段赋了值,那么他就不会为nil,然后挪用这个函数。这也就实现了我们的目的,在处置请求之前,先执行我们设置的函数。

3.3 思索

现在我们已经实现了一个完全解耦的中间件。而且,这个中间件是可以随便设置的。你可以拿来做日志纪录,也可以做权限校验等等,而且这些功效还不会对Handler中的营业逻辑造成影响。

若是你是个Java开发者,你可能会以为这个很像Filter,或者是AOP

然则,和过滤器差别的是,我们不仅可以在请求到来之前处置,也可以在请求完成之后处置。好比这个请求发生了一些panic,你可以在最后处置它,或者你可以纪录这个请求的时间等等,你要做的,只是在Handle方式之后,挪用你所注册的方式。

好比:

func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	...
	if root := r.trees[req.Method]; root != nil {
		if handle, ps, tsr := root.getValue(path, r.getParams); handle != nil {
		    if r.beforeHandler != nil{
				r.beforeHandler(w, req)
			}
			if ps != nil {
				handle(w, req, *ps)
				r.putParams(ps)
			} else {
				handle(w, req, nil)
			}
			if r.afterHandler != nil {
				r.afterHandler(w, req)
			}
			return
		} 
	}
    ...
}

我们只是添加了一个afterHandler方式,就是这么的简朴。

那么问题来了:现在这样的处置操作,我们仅仅只能在请求前和请求后各自添加一个中间件。若是我们想要添加随便多个中间件,该怎么做呢?

程序员到底要不要学习框架、库和工具

可以先自己思索一下,然后我们来看看在gin中,是怎么实现的。

4 Gin的中间件

4.1 使用

总所周知,在阅读源码之前,一定要先看看他是怎么用的:

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
)

func Hello(ctx *gin.Context) {
	fmt.Fprint(ctx.Writer, "Hello World!\n")
}

func main() {
	router := gin.New()
	router.Use(gin.Logger(), gin.Recovery())
	router.GET("/hello", Hello)
	router.Run(":8080")
}

可以看到,在gin中,使用中间件的方式和上文中我们所设计的是差不多的。都是营业和中间件完全解耦,而且在注册路由的时刻,添加进去。

然则我们注重到,在gin中是不分Handle之前照样Handle之后的。那么他是若何做到的呢,我们来看看源码。

4.2 源码注释

先从Use方式看起:

func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes {
	engine.RouterGroup.Use(middleware...)
	engine.rebuild404Handlers()
	engine.rebuild405Handlers()
	return engine
}

func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
	group.Handlers = append(group.Handlers, middleware...)
	return group.returnObj()
}

在这里我们先不管group这个器械,他是路由分组,和我们这篇文章没有关系,我们先不管他。我们只需要看到append方式。Use方式就是把参数内里的函数,所有增添到group.Handlers中。这里的group.Handlers,是一个Handler类型的数组。

以是,在gin中,每一个中间件,也是Handler类型的。

在上一节我们留了一个问题,要怎么实现多个中间件。谜底就在这里了,用数组保留。

那么问题又来了:怎么保证挪用的顺序呢?

我们继续往下看看路由的注册:

func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle(http.MethodGet, relativePath, handlers)
}

这里是不是也有点熟悉呢?和上一篇文章提到的httprouter很相似,我们直接看group.handle

func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) IRoutes {
	absolutePath := group.calculateAbsolutePath(relativePath)
	handlers = group.combineHandlers(handlers)
	group.engine.addRoute(httpMethod, absolutePath, handlers)
	return group.returnObj()
}

在这段代码中,第一行关于path的我们先不管,这个也是和路由分组有关的,简朴来说就是拼接出完整的请求path

先看看第二行,方式名是combineHandlers,我们可以预测一下这个方式的作用,把各个Handler结合起来。看看详细的代码:

func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain {
	finalSize := len(group.Handlers) + len(handlers)
	if finalSize >= int(abortIndex) {
		panic("too many handlers")
	}
	mergedHandlers := make(HandlersChain, finalSize)
	copy(mergedHandlers, group.Handlers)
	copy(mergedHandlers[len(group.Handlers):], handlers)
	return mergedHandlers
}

先注释一下,这里返回的HandlersChain类型,是Handler的数组。

也就是说,在这个方式内里,把之前放入group中的中间件,和当前路由的Handler,组合成一个新的数组。

而且,中间件在前面,路由Handler在后面。注重,这个顺序很主要

然后我们继续往下,执行完这个方式之后执行的就是addRoute方式了。在这里不展开讲。以是最主要的是,这里把中间件和Handler全都组合在了一起,绑定到了这个前缀树上。

到了这里注册方面的内容已经竣事了,我们来看看他是怎么处置各个中间件的挪用顺序

由于我们的目的是看路由是怎么处置请求的,以是我们直接看ginServeHTTP方式:

func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	c := engine.pool.Get().(*Context)
	c.writermem.reset(w)
	c.Request = req
	c.reset()

	engine.handleHTTPRequest(c)

	engine.pool.Put(c)
}

这里要注重的是*Context,他是对请求的封装,包罗了有responseWriter*http.Request等。

我们继续往下看看handleHTTPRequest(c)这个方式:

func (engine *Engine) handleHTTPRequest(c *Context) {
    httpMethod := c.Request.Method
	rPath := c.Request.URL.Path
	...
    t := engine.trees
	for i, tl := 0, len(t); i < tl; i++ {
		if t[i].method != httpMethod {
			continue
		}
		root := t[i].root
		// Find route in tree
		value := root.getValue(rPath, c.Params, unescape)
		if value.handlers != nil {
			c.handlers = value.handlers
			c.Params = value.params
			c.fullPath = value.fullPath
			c.Next()
			c.writermem.WriteHeaderNow()
			return
		}
		...
	}
	...
}

在这个方式中,实在和之前我们研究的httprouter是很相似的。也是先凭据请求方式找到相对应的前缀树,然后获取相对应的Handler,并把获取到的handler数组保留在Context中。

这里我们注重看c.Next()方式,他是gin中关于中间件的挪用最精妙的部门。我们来看看:

func (c *Context) Next() {
	c.index++
	for c.index < int8(len(c.handlers)) {
		c.handlers[c.index](c)
		c.index++
	}
}

我们可以看到,当挪用这个Next()方式的时刻,会增添保留在Context中的下标,然后凭据这个下标的顺序执行handler

而在前面我们有提到,我们把中间件排在了这个handler数组的前面,先执行中间件,然后最后才是执行用户自定义的handler

我们再来看看日志纪录这个中间件:

func LoggerWithConfig(conf LoggerConfig) HandlerFunc {
	...
	return func(c *Context) {
		//最先计时
		start := time.Now()
		path := c.Request.URL.Path
		raw := c.Request.URL.RawQuery

		c.Next()
		...
		// Stop timer
		param.TimeStamp = time.Now()
		param.Latency = param.TimeStamp.Sub(start)
		...
	}
}

可以看到,先最先计时,然后挪用了c.Next()这个方式,然后才竣事计时。

那么我们可以由此推断,c.Next()后面的代码,是执行完用户自定义的Handler才执行的。

Golang Web入门(3):若何优雅的设计中间件

也就是说,实在中间件的营业逻辑是这样的:

func Middleware(c *gin.Context){
    //请求前执行
    c.Next()
    //请求后执行
}

5 写在最后

首先,谢谢你能看到这里。

简朴的来讲,我们应该思量解耦合,使得营业代码可以专注于营业,中间件专注于实现功效。为了实现这点,我们可以修改路由的实现逻辑,在执行Handler的前后加入中间件的挪用。

在本文中,可能会有许多的疏漏。若是在阅读的历程中,有哪些注释不到位,或者作者的明白泛起了一些差错,也请你留言指正。

再次谢谢~

PS:若是有其他的问题,也可以在民众号找到作者。而且,所有文章第一时间会在民众号更新,迎接来找作者玩~

Golang Web入门(3):若何优雅的设计中间件

原创文章,作者:28x29新闻网,如若转载,请注明出处:https://www.28x29.com/archives/5585.html