Go语言经典库使用分析| Negroni 中间件

Posted 2021-04-05 飞雪无情

上一篇  中介绍了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的再次调用，这是一个递归，也是中间件处理链设计的巧妙之处，灵活控制，自由的选择是否调用下个中间件。

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

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

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

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的包装，增加了一些额外的信息，这个知识点我在这个篇  文章里详细介绍过，就不再重复介绍了。

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

相关文章推荐