Go的Negroni库

Go的Negroni库

Negroni库下载安装

go get -u github.com/urfave/negroni

Negroni库的结构

这是Negroni库的函数大致结构

首先由课上老师追踪Go的web服务包说起
（此追踪流程出自http://blog.csdn.net/pmlpml/article/details/78404838）

ListenAndServe(addr string, handler Handler)  + server.ListenAndServe()    | net.Listen("tcp", addr)    + srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})      | srv.setupHTTP2_Serve()      | baseCtx := context.Background()      + for {}        | l.Accept()        |  + select ... //为什么        | c := srv.newConn(rw)        | c.setState(c.rwc, StateNew) // before Serve can return        + go c.serve(ctx) // 新的链接 goroutine          | ...  // 构建 w , r          | serverHandler{c.server}.ServeHTTP(w, w.req)          | ...  // after Serve

可以看到Go的http包在serverHandler{c.server}.ServeHTTP(w, w.req) 实现每个 conn 对应一个 serverHandler 的处理函数。
而在Negroni包中则只是实现了这一接口，该库可以认为是为了方便我们实现Handler.
那么首先我们从这个接口的实现开始，在http包中存在这么一个接口

type Handler interface {    ServeHTTP(ResponseWriter, *Request)}

而在Negroni包中首先是该接口的实现

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

可以看到Negroni类型将处理丢给了middleware处理，那么我们看看Negroni里的middleware以及其他成员

type Negroni struct {    middleware middleware    handlers   []Handler}

可以看到有一个Handler的切片和一个middleware，对于这两者，其定义分别是

type middleware struct {    handler Handler    next    *middleware}

这个定义就类似与c语言的链表结构了，可以将其理解为middleware是用来连接handler的数据结构吧
而对于Handler，其定义如下

// Handler handler is an interface that objects can implement to be registered to serve as middleware// in the Negroni middleware stack.// ServeHTTP should yield to the next middleware in the chain by invoking the next http.HandlerFunc// passed in.//// If the Handler writes to the ResponseWriter, the next http.HandlerFunc should not be invoked.type Handler interface {    ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)}

这里Handler将http接口稍微做了拓展，这是http.HandlerFunc的定义

// The HandlerFunc type is an adapter to allow the use of// ordinary functions as HTTP handlers. If f is a function// with the appropriate signature, HandlerFunc(f) is a// Handler that calls f.type HandlerFunc func(ResponseWriter, *Request)

可以看到本质上这与我们前面说到的http包调用的接口ServeHTTP是一个类型，Negroni包定义的Handler类型只是增加了一个指向http.HandlerFunc的参数，你可以在下文看到它会将所有handler形成链状结构
在Negroni包的Handler interface下面也有一段类似的HandlerFunc

// HandlerFunc is an adapter to allow the use of ordinary functions as Negroni handlers.// If f is a function with the appropriate signature, HandlerFunc(f) is a Handler object that calls f.type HandlerFunc func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

现在我们回过头看刚刚的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)}

可以看到它调用了自己的成员handler的ServeHTTP，那么我们看一下对应函数

// HandlerFunc is an adapter to allow the use of ordinary functions as Negroni handlers.// If f is a function with the appropriate signature, HandlerFunc(f) is a Handler object that calls f.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)}

可以看到它是将HandlerFunc进行执行，至此我们追踪完上面那个结构图的右边部分，那么HandlerFunc又是在哪里初始化或者传入Negroni中呢，我们先从github上给的start代码追踪一下

package mainimport (  "github.com/urfave/negroni"  "net/http"  "fmt")func main() {  mux := http.NewServeMux()  mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {    fmt.Fprintf(w, "Welcome to the home page!")  })  n := negroni.Classic()  n.UseHandler(mux)  n.Run(":3000")}

可以看到这里在UseHandler这里传入了HandleFunc（虽然类型和我们刚刚看到的Negroni定义的Handler不一样），我们尝试追踪一下UseHandler()

// UseHandler adds a http.Handler onto the middleware stack. Handlers are invoked in the order they are added to a Negroni.func (n *Negroni) UseHandler(handler http.Handler) {    n.Use(Wrap(handler))}// UseHandlerFunc adds a http.HandlerFunc-style handler function onto the middleware stack.func (n *Negroni) UseHandlerFunc(handlerFunc func(rw http.ResponseWriter, r *http.Request)) {    n.UseHandler(http.HandlerFunc(handlerFunc))}

这里我们可以看到两个差不多的函数（后面一个本质上是调用前一个实现相同功能），这里传入的是http包的Handler类型，我们看一下Wrap()函数

// Wrap converts a http.Handler into a negroni.Handler so it can be used as a Negroni// middleware. The next http.HandlerFunc is automatically called after the Handler// is executed.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)    })}// WrapFunc converts a http.HandlerFunc into a negroni.Handler so it can be used as a Negroni// middleware. The next http.HandlerFunc is automatically called after the Handler// is executed.func WrapFunc(handlerFunc http.HandlerFunc) Handler {    return HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {        handlerFunc(rw, r)        next(rw, r)    })}

可以看到这里Wrap()函数将http.Handler类型转为一个执行完本次handler然后执行next对应的handler的Negroni包的Handler类型
接着我们看一下UseHandler函数里面调用的Use函数

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

这里将传进来的handler加入handlers切片，然后调用build函数建立middleware，我们看一下build函数以及剩下的相关函数

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{},    }}

可以看到这是一个简单的递归过程，把handler拼成链表，然后建立middleware，至此我们可以看到Negroni库就是将你传进去的函数建成链表，然后由于Wrap()函数，默认会调用next()，也就是handler构成的链会一直调用到最后一个空的函数（即上示的voidMiddleware()返回的函数），当http包调用接口的时候，Negroni会执行middleware头指针（这只是类比）的handler然后一直往后面调用，这就是我们一开始给出的那张结构图了。

剩下的一些小细节

注意到刚刚的UseHandler等函数都是默认一直执行next的，那么有没有不执行next的呢，这里Negroni库提供了一个方法给你不调用next

func (n *Negroni) UseFunc(handlerFunc func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)) {    n.Use(HandlerFunc(handlerFunc))}

这里很显然就必须传入该包定义的Handler类型的函数作为参数。
剩下的还有Negroni的几个构造函数和Run之类的就不多讲，这里稍微看看就好

gofunc New(handlers ...Handler) *Negroni {    return &Negroni{        handlers:   handlers,        middleware: build(handlers),    }}

这是简单的New
然后这是类似与在尾部加上handler的构造函数

func (n *Negroni) With(handlers ...Handler) *Negroni {    return New(        append(n.handlers, handlers...)...,    )}

然后是Classical，这里面的logger等都在该库另外的go文件实现了，这是Negroni内置的另外三个类型

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