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 反向应用中间件,保持声明顺序与请求执行顺序一致。

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

预期输出

text
listening on :8080

实际监听端口可以按环境调整;若端口不是 8080,请把后续请求中的地址替换为实际 <PORT>。

验证共享与专属行为

依次请求公开路由、未认证的私有路由和带令牌的私有路由。三个请求都会经过日志与追踪中间件,但只有私有路由需要 Authorization。

bash
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

预期输出

text
public ok

HTTP 200
unauthorized

HTTP 401
private ok

HTTP 200

服务端终端还会为每个请求记录方法、路径和最终状态码;X-Request-ID 会写入响应头,具体 <ID> 会随请求次数变化。

设计边界

共享中间件应挂在“最小但足够公共”的路由树外层。日志、追踪、恢复通常适合覆盖整组路由;鉴权、租户校验、权限检查往往只适合某个子树或单一路由。把所有规则都堆到全局链上,会迫使公开接口不断写例外分支,反而增加维护成本。

中间件顺序也属于行为的一部分。若希望未授权请求也有请求 ID 并被日志记录,就应让追踪和日志位于鉴权外层;若某层会短路响应,位于它内侧的中间件将不会执行。把顺序固定在一个组合函数或路由装配位置,比在每个处理器里手工调用更容易审查。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

让多个路由共享中间件

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通