Go语言经典库使用分析,未完待续,欢迎扫码关注公众号flysnow_org或者网站http://www.flysnow.org/,第一时间看后续系列。觉得有帮助的话,顺手分享到朋友圈吧,感谢支持。

上一篇 Go语言经典库使用分析(五)| Negroni 中间件(一) 中介绍了Negroni中间的入门使用和一些介绍,比如如何添加中间等,中间件的路由等。这一篇主要讲原理,比如如何构建的中间处理链,如何编写自己的中间件等。

Negroni Handler处理器

本质上来说Negroni是一个HTTP Handler,因为他实现了HTTP Handler接口,所以他可以被http.ListenAndServe使用,其次Negroni本身内部又有一套自己的Handler处理链,通过他们可以达到处理http请求的目的,这些Handler处理链中的处理器,就是一个个中间件。

1
2
3
func (n *Negroni) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
	n.middleware.ServeHTTP(NewResponseWriter(rw), r)
}

以上代码,是Negroni实现了HTTP的Handler,这样就和标注库里的http无缝整合了。实现了HTTP Handler,对于HTTP Request来说,就有一个统一的入口,所有的对HTTP Requet的处理,都会被Negroni通过ServeHTTP方法转交给Negroni内部注册的中间件。

1
2
3
4
5
type Handler interface {
	ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)
}

type HandlerFunc func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

这是Negroni自己定义的Handler处理器,它和HTTP Handler非常相似,唯一不同的是多了一个next参数,这个next参数是组成中间件处理链的核心。

如何构建中间件处理链

我们已经知道了Negroni有自己的一套Handler中间件处理链,那么这个处理链和如何构建的呢?要想解开这个谜底,我们先看下Negroni如何注册一个中间件的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
type Negroni struct {
	middleware middleware
	handlers   []Handler
}

func (n *Negroni) Use(handler Handler) {
	if handler == nil {
		panic("handler cannot be nil")
	}

	n.handlers = append(n.handlers, handler)
	n.middleware = build(n.handlers)
}

在我们调用Use方法的时候,会把Negroni的Handler存在自己的handlers字段中,这是一个Slice类型字段,可以保存我们存放的Negroni Handler。同时会基于这个存放Negroni Handler的Slice构建中间件处理链middleware

1
2
3
4
type middleware struct {
	handler Handler
	next    *middleware
}

middleware struct有很简单,有两个字段,一个是当前的Negroni Handler,一个是指向下一个middleware的指针next。有了这样一个middleware struct,就可以构建一个完美的中间件处理链了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
func build(handlers []Handler) middleware {
	var next middleware

	if len(handlers) == 0 {
		return voidMiddleware()
	} else if len(handlers) > 1 {
		next = build(handlers[1:])
	} else {
		next = voidMiddleware()
	}

	return middleware{handlers[0], &next}
}

func voidMiddleware() middleware {
	return middleware{
		HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {}),
		&middleware{},
	}
}

以上代码就是构建一个中间件处理链的逻辑,这是一个递归的函数,逻辑比较简单。

handlers参数为空的时候,直接通过voidMiddleware函数返回一个空的middleware。 当handlers参数只有1个处理器的时候,构建的milldeware就没有next了,所以next是通过voidMiddleware函数获得的,然后再通过return middleware{handlers[0], &next}组成生成的middleware并返回。

最后一种情况,就是有1个以上的Negroni Handler,那就通过build函数循环递归了,从第2个Handler开始,不停的往后递归处理,所以最先被添加的Negroni Handler会被放在中间件处理链的前面,也就意味着会被优先执行。

中间件如何被调用

构建好了处理器链,那么这些中间件如何被调用的呢?前面的章节,我们讲了Negroni是一个HTTP Handler,所以总的入口在ServeHTTP方法里。

1
2
3
func (n *Negroni) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
	n.middleware.ServeHTTP(NewResponseWriter(rw), r)
}

从以上代码可以看出,调用了middleware.ServeHTTP方法,这就是中间件被执行的开始。

1
2
3
func (m middleware) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
	m.handler.ServeHTTP(rw, r, m.next.ServeHTTP)
}

middleware.ServeHTTP方法调用middleware中当前handler的ServeHTTP方法执行我们自己写的中间件处理逻辑。

1
2
3
4
5
type HandlerFunc func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

func (h HandlerFunc) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
	h(rw, r, next)
}

又回到这里了吧,handler的ServeHTTP方法执行,本质上就是执行的我们自己定义的negroni.HandlerFunc。

当前的中间件被执行了,那么下一个如何被触发的?这就是我们自己定义的中间件函数中的next参数了。我们在自己的中间件处理结束后,如果觉得有必要,就需要调用next函数,继续执行下一个中间件,如果我们不调用next函数,那么中间件链的处理,到这里就断了。看一个自定义中间件的例子。

1
2
3
4
5
6
7
func (l *Logger) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
	start := time.Now()

	next(rw, r)

	//省略无关代码
}

这是Negroni内置的log中间件的实现,可以看到,它调用了next(rw, r)函数,让中间件处理链继续执行。这个next(rw, r)是什么呢?其实前面我们讲过。

1
2
3
func (m middleware) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
	m.handler.ServeHTTP(rw, r, m.next.ServeHTTP)
}

next函数的调用,就是对下一个middlewareServeHTTP的再次调用,这是一个递归,也是中间件处理链设计的巧妙之处,灵活控制,自由的选择是否调用下个中间件。

Go语言经典库使用分析,未完待续,欢迎扫码关注公众号flysnow_org或者网站http://www.flysnow.org/,第一时间看后续系列。觉得有帮助的话,顺手分享到朋友圈吧,感谢支持。

http Handler和negroni Handler之间的转换

在刚介绍Negroni的时候,我们知道,它是兼容HTTP Handler的,Negroni可以直接把HTTP Handler转换为Negroni HTTP,让我们可以直接使用HTTP Handler作为Negroni的中间件,下面我们看下是如何转换的。

1
2
3
4
5
6
7
func (n *Negroni) UseHandler(handler http.Handler) {
	n.Use(Wrap(handler))
}

func (n *Negroni) UseHandlerFunc(handlerFunc func(rw http.ResponseWriter, r *http.Request)) {
	n.UseHandler(http.HandlerFunc(handlerFunc))
}

Negroni提供两个方法,分别兼容http.Handlerhttp.HandlerFuncUseHandlerFunc方法本质上还是调用的UseHandler方法,UseHandler方法实现的重点就是Wrap(handler),它完成了http.Handler到negroni.Handler的转换。

1
2
3
4
5
6
func Wrap(handler http.Handler) Handler {
	return HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
		handler.ServeHTTP(rw, r)
		next(rw, r)
	})
}

这个函数本质上是Negroni中间件的实现,它的代码逻辑就是先执行http.Handler中间件的实现,然后调用next(rw, r)执行下一个中间件。

内置中间件介绍

Negroni内置了几个中间件,当我们通过Classic函数创建一个*Negroni的时候,就会有

1
2
3
func Classic() *Negroni {
	return New(NewRecovery(), NewLogger(), NewStatic(http.Dir("public")))
}

NewRecovery,NewLoggerNewStatic就是这几个内置的中间件,都是实现了negroni handler而成的中间件,具体源代码大家可以看下,这里就不具体介绍了。

编写自己的中间件

编写自己的中间件,在Negroni可以采用两种方式,一种是http.Handler的方式,这种方式优点是大家都熟悉,并且已经会了,缺点也有,就是不能控制中间件的处理链,默认是调用下一个中间件的,我们不能中断。

另外一个就是实现negroni.Handler的方式,Negroni推荐的也是这种方式。

 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
//Blog:www.flysnow.org
//Wechat:flysnow_org
func main() {
	n := negroni.New()
	n.UseFunc(printAuthorInfo)

	router:=http.NewServeMux()
	router.Handle("/",handler())

	n.UseHandler(router)

	n.Run(":1234")

}

func printAuthorInfo(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc){
	fmt.Println("Blog:www.flysnow.org")
	fmt.Println("Wechat:flysnow_org")
	next(rw,r)
}


func handler() http.Handler{
	return http.HandlerFunc(myHandler)
}

func myHandler(rw http.ResponseWriter, r *http.Request) {
	rw.Header().Set("Content-Type", "text/plain")
	io.WriteString(rw,"Hello World")
}

我们通过printAuthorInfo函数实现了一个Negroni Handler中间件,这个中间件很简单,只是打印一些作者信息,然后就执行下一个中间件。

使用的时候,我们通过n.UseFunc(printAuthorInfo)注册这个中间件,我们启动服务,访问http://localhost:1234的时候,就可以在控制台看到如下信息:

1
2
Blog:www.flysnow.org
Wechat:flysnow_org

为了举例,我这个中间件比较简单,大家可以根据自己的需求实现满足自己业务的中间件。

一些中间件介绍

Github上有很多专门为Negroni开发的第三方中间件,以配合Negroni的使用,比如gzip的,oauth2.0的等,大家可以通过如下链接查看第三方的中间列表:

https://github.com/urfave/negroni#third-party-middleware

小结

到这里,Negroni这个中间件分析完了,可能还有一些没有分析的,比如With方法,Run方法,他们都是比较简单的,大家看下就可以了。

还有一个比较重要的是NewResponseWriter这个函数,它是对我们现在的NewResponseWriter的包装,增加了一些额外的信息,这个知识点我在这个篇 Go语言经典库使用分析(四)| Gorilla Handlers 源代码实现分析 文章里详细介绍过,就不再重复介绍了。

HTTP的中间件,就是一个HTTP的拦截器,Negroni对于该拦截器处理的更好,可以灵活控制,是否终端等,合理的使用Negroni,可以让你事半功倍。

相关文章推荐

Go语言经典库使用分析(五)| Negroni 中间件(一)

Go语言经典库使用分析(四)| Gorilla Handlers 源代码实现分析

Go语言经典库使用分析(三)| Gorilla Handlers 详细介绍

Go语言经典库使用分析(二)| Gorilla Context

Go语言经典库使用分析,未完待续,欢迎扫码关注公众号flysnow_org或者网站http://www.flysnow.org/,第一时间看后续系列。觉得有帮助的话,顺手分享到朋友圈吧,感谢支持。

扫码关注