Go语言经典库使用分析（六）| Negroni 中间件（二）

飞雪无情

发布于 2018-08-28 03:23:43

42700

代码可运行

文章被收录于专栏：飞雪无情的博客飞雪无情的博客

运行总次数：0

代码可运行

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

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

Negroni Handler处理器

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

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内部注册的中间件。

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如何注册一个中间件的。

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。

type middleware struct {
	handler Handler
	next    *middleware
}

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

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方法里。

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

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

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

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

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函数，那么中间件链的处理，到这里就断了。看一个自定义中间件的例子。

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)是什么呢？其实前面我们讲过。

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

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

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

http Handler和negroni Handler之间的转换

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

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.Handler和http.HandlerFunc，UseHandlerFunc方法本质上还是调用的UseHandler方法，UseHandler方法实现的重点就是Wrap(handler)，它完成了http.Handler到negroni.Handler的转换。

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的时候，就会有

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

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

编写自己的中间件

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

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

//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")
}