negroni本身是一箇中間件，不過它也提供了拓展，以幫助我們更簡單地實現自己想要的功能的中介軟體。那麼，我們究竟該如何實現中介軟體，才能能夠封裝到negroni中，從而通過negroni來呼叫呢？可以通過一個簡單的例子分析：

package main
import (
"fmt"
"net/http"

"github.com/urfave/negroni"
"github.com/phyber/negroni-gzip/gzip"
)

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() //建立一個negroni
n.Use(gzip.Gzip(gzip.DefaultCompression))
n.UseHandler(mux)
n.Run(":3000")
}

　　我們從negroni建立之後開始分析。n.UseHandler(mux)函式：

n.UseHandler(mux)
    +func (n *Negroni) UseHandler(handler http.Handler)
        |n.Use(Wrap(handler))
        +func Wrap(handler http.Handler
 
) Handler
            |return HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)
        +func (n *Negroni) Use(handler Handler)
            |n.handlers = append(n.handlers, handler)
            |n.middleware = build(n.handlers)
            +func build(handlers []Handler
 
) middleware
                |return middleware{handlers[0], &next}

　　呼叫n.UseHandler(mux)函式的過程中，同樣也呼叫了n.Use()函式。說明negroni對於第三方中介軟體的使用是從n.UseHandler開始的。
　　接下來，一起來分析追蹤過程中遇到的函式：

1. UseHandler

　　該函式返回將handler傳遞給Wrap()函式

func (n *Negroni) UseHandler(handler http.Handler) {
    n.Use(Wrap(handler))
}

2. Wrap

　　該函式對handler進行封裝，程式設計固定format的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)
    })
}

3. Use

　　該函式則將handler新增到Negroni結構體中。其中，midlleware是一個連結串列。

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

+-----------------------------------------+
type Negroni struct {
    middleware middleware
    handlers   []Handler
}

type middleware struct {
    handler Handler
    next    *middleware
}

4. build

　　如果你瞭解C/C++，這個函式很好理解。它僅僅是一個迭代函式，實現了middleware連結串列的構建。

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

5. 對ServerHTTP的處理

　　同時，我們也要清楚Handler是一個介面，一個Handler物件必須實現Handler介面。Handler介面定義如下：

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

　　negroni對ServeHTTP做了哪些處理呢？通過以下三個函式可以瞭解：

//函式型別，使用HandleFunc會呼叫
//func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)的實現
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)
}

//實現ServerHTTP的封裝
func (m middleware) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
    m.handler.ServeHTTP(rw, r, m.next.ServeHTTP)
}

接下來，我們追蹤n.Run(“:3000”)函式：

n.Run(":3000")
    +func (n *Negroni) Run(addr ...string)
    |finalAddr := detectAddress(addr...)
        +func detectAddress(addr ...string) string
    |l.Fatal(http.ListenAndServe(finalAddr, n))
        +func ListenAndServe(addr string, handler Handler) error
        |......

　　negroni.Run解析address後，最終呼叫了http.ListenAndServe來實現伺服器。這一步，才最終完成了伺服器的搭建；所有的handler都交付給了http.ListenAndServe去實現。


　　關於negroni對於第三方中介軟體的使用就分析到這裡了。