Go / 系统课时
让多个路由共享中间件
让多个路由共享中间件
当日志、鉴权、请求追踪都直接写进每个处理器时,路由一多就会出现重复代码和执行顺序不一致。本文用 http.Handler 的包装模式把横切逻辑组合成中间件链,让公共中间件只挂一次,同时允许敏感路由追加自己的鉴权规则。
学习目标
- 理解 Go 中间件本质上是“接收一个
http.Handler,返回一个新的http.Handler”。 - 用可控的组合顺序让多个路由共享日志和追踪逻辑,并为单一路由叠加鉴权。
- 通过请求结果验证公共链与路由专属中间件是否按预期执行。
中间件为什么适合包装 Handler
标准库没有强制的中间件类型,但最常见的形式可以定义为 func(http.Handler) http.Handler。每个中间件在调用 next.ServeHTTP 之前处理请求,调用之后还能处理响应阶段逻辑,因此天然适合日志、追踪、鉴权、限流等横切关注点。
组合时通常从切片末尾向前包装。这样声明顺序 logging, trace 会得到“请求先经过 logging,再经过 trace;响应再反向返回”的直觉顺序。

组织共享链和专属规则
下面的示例把日志和请求追踪放在整个 ServeMux 外层,因此 /public 与 /private 自动共享这两层逻辑;只有 /private 在注册时额外包一层鉴权。chain 反向应用中间件,保持声明顺序与请求执行顺序一致。
package main
import (
"fmt"
"log"
"net/http"
"sync/atomic"
)
type Middleware func(http.Handler) http.Handler
var requestSeq uint64
func chain(h http.Handler, middlewares ...Middleware) http.Handler {
for i := len(middlewares) - 1; i >= 0; i-- {
h = middlewares[i](h)
}
return h
}
type statusWriter struct {
http.ResponseWriter
status int
}
func (w *statusWriter) WriteHeader(code int) {
w.status = code
w.ResponseWriter.WriteHeader(code)
}
func (w *statusWriter) Write(p []byte) (int, error) {
if w.status == 0 {
w.WriteHeader(http.StatusOK)
}
return w.ResponseWriter.Write(p)
}
func loggingMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
sw := &statusWriter{ResponseWriter: w}
next.ServeHTTP(sw, r)
status := sw.status
if status == 0 {
status = http.StatusOK
}
log.Printf("method=%s path=%s status=%d", r.Method, r.URL.Path, status)
})
}
func traceMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := r.Header.Get("X-Request-ID")
if id == "" {
id = fmt.Sprintf("req-%d", atomic.AddUint64(&requestSeq, 1))
}
w.Header().Set("X-Request-ID", id)
next.ServeHTTP(w, r)
})
}
func authMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Header.Get("Authorization") != "Bearer demo-token" {
http.Error(w, "unauthorized", http.StatusUnauthorized)
return
}
next.ServeHTTP(w, r)
})
}
func main() {
log.SetFlags(0)
api := http.NewServeMux()
api.HandleFunc("/public", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "public ok")
})
api.Handle("/private", authMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "private ok")
})))
handler := chain(api, loggingMiddleware, traceMiddleware)
log.Println("listening on :8080")
log.Fatal(http.ListenAndServe(":8080", handler))
}预期输出
listening on :8080实际监听端口可以按环境调整;若端口不是 8080,请把后续请求中的地址替换为实际 <PORT>。
验证共享与专属行为
依次请求公开路由、未认证的私有路由和带令牌的私有路由。三个请求都会经过日志与追踪中间件,但只有私有路由需要 Authorization。
curl -sS -o - -w '\nHTTP %{http_code}\n' http://localhost:8080/public
curl -sS -o - -w '\nHTTP %{http_code}\n' http://localhost:8080/private
curl -sS -o - -w '\nHTTP %{http_code}\n' -H 'Authorization: Bearer demo-token' http://localhost:8080/private预期输出
public ok
HTTP 200
unauthorized
HTTP 401
private ok
HTTP 200服务端终端还会为每个请求记录方法、路径和最终状态码;X-Request-ID 会写入响应头,具体 <ID> 会随请求次数变化。
设计边界
共享中间件应挂在“最小但足够公共”的路由树外层。日志、追踪、恢复通常适合覆盖整组路由;鉴权、租户校验、权限检查往往只适合某个子树或单一路由。把所有规则都堆到全局链上,会迫使公开接口不断写例外分支,反而增加维护成本。
中间件顺序也属于行为的一部分。若希望未授权请求也有请求 ID 并被日志记录,就应让追踪和日志位于鉴权外层;若某层会短路响应,位于它内侧的中间件将不会执行。把顺序固定在一个组合函数或路由装配位置,比在每个处理器里手工调用更容易审查。