Go / 系统课时
构建中间件链
构建中间件链
Go 中间件的核心不是某个框架 API,而是用函数包装 http.Handler。本篇直接实现一条可组合的处理链,并用鉴权短路和状态码包装验证进入顺序、返回顺序以及提前结束请求时哪些逻辑仍会执行。
学习目标
- 编写接收并返回
http.Handler的中间件,并按预期顺序组合。 - 判断中间件进入、业务处理与返回阶段的实际执行顺序。
- 正确实现短路响应,并理解包装
http.ResponseWriter时的边界。
中间件本质是逐层包装
一个中间件可以定义为 func(http.Handler) http.Handler:参数是“下一层处理器”,返回值是“包装后的新处理器”。多个中间件组合后形成嵌套结构,请求从最外层向内进入,next.ServeHTTP 返回后再从内向外退出。
如果希望 Chain(app, Logging, Auth) 中的 Logging 最先执行,就要从切片尾部反向包装。这样声明顺序与阅读顺序一致,不必让调用者反着写中间件列表。

用一个主示例验证链路
下面的程序实现日志中间件、鉴权中间件和状态码包装器。第一次请求没有令牌,会在鉴权层短路;第二次请求通过鉴权,才会进入业务处理器。httptest.NewServer 让示例无需手工占用固定端口即可运行。
package main
import (
"fmt"
"io"
"net/http"
"net/http/httptest"
"strings"
)
type Middleware func(http.Handler) http.Handler
func Chain(final http.Handler, middlewares ...Middleware) http.Handler {
for i := len(middlewares) - 1; i >= 0; i-- {
final = middlewares[i](final)
}
return final
}
type statusWriter struct {
http.ResponseWriter
status int
}
func (w *statusWriter) WriteHeader(code int) {
if w.status == 0 {
w.status = code
}
w.ResponseWriter.WriteHeader(code)
}
func (w *statusWriter) Write(p []byte) (int, error) {
if w.status == 0 {
w.status = http.StatusOK
}
return w.ResponseWriter.Write(p)
}
func Logging(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
sw := &statusWriter{ResponseWriter: w}
fmt.Println("logging: before")
next.ServeHTTP(sw, r)
status := sw.status
if status == 0 {
status = http.StatusOK
}
fmt.Printf("logging: after status=%d\n", status)
})
}
func Auth(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Header.Get("Authorization") != "Bearer demo-token" {
fmt.Println("auth: reject")
http.Error(w, "unauthorized", http.StatusUnauthorized)
return // 短路:不再调用下一层
}
fmt.Println("auth: passed")
next.ServeHTTP(w, r)
})
}
func call(url, token string) {
req, err := http.NewRequest(http.MethodGet, url, nil)
if err != nil {
panic(err)
}
if token != "" {
req.Header.Set("Authorization", token)
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
panic(err)
}
fmt.Printf("client: status=%d body=%q\n",
resp.StatusCode, strings.TrimSpace(string(body)))
}
func main() {
app := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Println("handler: run")
fmt.Fprintln(w, "ok")
})
server := httptest.NewServer(Chain(app, Logging, Auth))
defer server.Close()
call(server.URL, "")
call(server.URL, "Bearer demo-token")
}预期输出
logging: before
auth: reject
logging: after status=401
client: status=401 body="unauthorized"
logging: before
auth: passed
handler: run
logging: after status=200
client: status=200 body="ok"从结果可以看到,短路只会阻止更内层的处理器继续执行;已经进入的外层中间件仍会在 next.ServeHTTP 返回后执行收尾逻辑。因此计时、日志和指标通常放在外层,鉴权、限流等中间件则可以在条件不满足时立即返回。
响应包装要保留真实能力
示例中的 statusWriter 记录显式 WriteHeader 和隐式 200 OK,适合说明状态采集。但生产代码不能默认“嵌入 http.ResponseWriter 就等于完全透明”:流式响应、连接劫持或推送等能力可能依赖额外接口。
如果中间件只需要观察状态码和字节数,包装器应尽量少改写行为;如果业务依赖刷新、全双工或连接控制,应确认包装后仍能提供对应能力,或使用标准库提供的响应控制能力。中间件的职责越单一,组合后越容易推理和测试。
组合顺序就是行为的一部分
Logging 放在 Auth 外层时,拒绝请求也会被记录;如果把顺序改成 Chain(app, Auth, Logging),鉴权失败会在进入日志中间件前结束,日志层看不到这次请求。缓存、压缩、恢复、鉴权和指标也都有类似的顺序效应。
因此不要把中间件列表当成“无序插件集合”。先明确谁必须观察所有请求、谁允许短路、谁依赖前一层写入的上下文,再决定组合顺序,并用至少一条成功路径和一条短路路径做验证。