Golang HTTP中间件实现及Negroni使用指南

在Go语言中，HTTP中间件是一种非常强大且常用的模式，它允许我们在处理HTTP请求和响应的过程中插入自定义逻辑。下面我将介绍Go中实现HTTP中间件的几种方式，并重点介绍Negroni这个流行的中间件库。

1. 原生Go实现HTTP中间件

基本中间件模式

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        // 在调用处理程序前执行的操作
        log.Printf("Started %s %s", r.Method, r.URL.Path)
        
        // 调用下一个处理程序
        next.ServeHTTP(w, r)
        
        // 在处理程序完成后执行的操作
        log.Printf("Completed %s in %v", r.URL.Path, time.Since(start))
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, World!"))
    })
    
    // 使用中间件包装处理器
    wrappedMux := loggingMiddleware(mux)
    
    http.ListenAndServe(":8080", wrappedMux)
}

多中间件链式调用

func middlewareOne(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println("Executing middlewareOne")
        next.ServeHTTP(w, r)
        log.Println("Executing middlewareOne again")
    })
}

func middlewareTwo(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println("Executing middlewareTwo")
        if r.URL.Path == "/forbidden" {
            w.WriteHeader(http.StatusForbidden)
            return
        }
        next.ServeHTTP(w, r)
        log.Println("Executing middlewareTwo again")
    })
}

func main() {
    finalHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println("Executing finalHandler")
        w.Write([]byte("OK"))
    })
    
    // 构建中间件链
    chain := middlewareOne(middlewareTwo(finalHandler))
    
    http.ListenAndServe(":8080", chain)
}

2. 使用Negroni中间件库

Negroni是一个专注于HTTP中间件的微型库，它提供了更简洁的方式来组织和组合中间件。

安装Negroni

go get github.com/urfave/negroni

基本使用示例

package main

import (
    "fmt"
    "net/http"
    "time"
    
    "github.com/urfave/negroni"
)

func main() {
    // 创建新的Negroni实例
    n := negroni.New()
    
    // 添加内置中间件
    n.Use(negroni.NewRecovery())  // 崩溃恢复
    n.Use(negroni.NewLogger())    // 请求日志
    
    // 添加自定义中间件
    n.Use(negroni.HandlerFunc(func(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
        fmt.Println("Before request")
        start := time.Now()
        
        next(w, r)
        
        fmt.Printf("After request (took %v)\n", time.Since(start))
    }))
    
    // 设置路由处理器
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        fmt.Fprintf(w, "Welcome to the home page!")
    })
    
    // 将路由器作为最后一个处理器
    n.UseHandler(mux)
    
    // 启动服务器
    http.ListenAndServe(":3000", n)
}

Negroni中间件类型

Negroni支持三种形式的中间件：

1. negroni.Handler 接口实现
2. negroni.HandlerFunc 函数适配器
3. http.Handler 接口实现

// 1. 实现negroni.Handler接口
type CustomMiddleware struct{}

func (m *CustomMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
    fmt.Println("CustomMiddleware before")
    next(w, r)
    fmt.Println("CustomMiddleware after")
}

// 2. 使用negroni.HandlerFunc
middlewareFunc := negroni.HandlerFunc(func(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
    fmt.Println("HandlerFunc before")
    next(w, r)
    fmt.Println("HandlerFunc after")
})

// 3. 使用http.Handler
httpMiddleware := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    fmt.Println("http.Handler middleware")
})

常用Negroni中间件

Negroni生态系统中有许多有用的中间件：

n := negroni.New()

// 静态文件服务
n.Use(negroni.NewStatic(http.Dir("public")))

// 添加多个中间件
n.Use(
    negroni.NewRecovery(),
    negroni.NewLogger(),
    &CustomMiddleware{},
    middlewareFunc,
    negroni.Wrap(httpMiddleware),
)

路由集成

Negroni常与Gorilla Mux或httprouter等路由器配合使用：

import (
    "github.com/gorilla/mux"
    "github.com/urfave/negroni"
)

func main() {
    router := mux.NewRouter()
    router.HandleFunc("/", homeHandler)
    router.HandleFunc("/products", productsHandler)
    
    n := negroni.New(
        negroni.NewRecovery(),
        negroni.NewLogger(),
    )
    
    n.UseHandler(router)
    http.ListenAndServe(":3000", n)
}

3. 创建可配置的中间件

func NewAuthMiddleware(realm string) negroni.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
        user, pass, ok := r.BasicAuth()
        
        if !ok || user != "admin" || pass != "secret" {
            w.Header().Set("WWW-Authenticate", `Basic realm="`+realm+`"`)
            w.WriteHeader(401)
            w.Write([]byte("Unauthorized\n"))
            return
        }
        
        next(w, r)
    }
}

func main() {
    n := negroni.New()
    n.Use(NewAuthMiddleware("Restricted Area"))
    
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Welcome to the protected area!"))
    })
    
    n.UseHandler(mux)
    http.ListenAndServe(":3000", n)
}

总结

Negroni提供了一种简洁、灵活的方式来组织HTTP中间件，它的设计哲学是"做一件事并做好"。相比原生实现，Negroni提供了：

1. 更清晰的中间件链式调用语法
2. 内置常用中间件（日志、恢复等）
3. 更好的与各种路由器集成
4. 更直观的中间件编写方式

对于大多数项目，使用Negroni可以显著简化中间件的管理和维护工作，同时保持代码的清晰和可维护性。