Go / 系统课时

构建中间件链

构建中间件链

Go 中间件的核心不是某个框架 API,而是用函数包装 http.Handler。本篇直接实现一条可组合的处理链,并用鉴权短路和状态码包装验证进入顺序、返回顺序以及提前结束请求时哪些逻辑仍会执行。

学习目标

  • 编写接收并返回 http.Handler 的中间件,并按预期顺序组合。
  • 判断中间件进入、业务处理与返回阶段的实际执行顺序。
  • 正确实现短路响应,并理解包装 http.ResponseWriter 时的边界。

中间件本质是逐层包装

一个中间件可以定义为 func(http.Handler) http.Handler:参数是“下一层处理器”,返回值是“包装后的新处理器”。多个中间件组合后形成嵌套结构,请求从最外层向内进入,next.ServeHTTP 返回后再从内向外退出。

如果希望 Chain(app, Logging, Auth) 中的 Logging 最先执行,就要从切片尾部反向包装。这样声明顺序与阅读顺序一致,不必让调用者反着写中间件列表。

中间件链进入、短路与返回顺序

用一个主示例验证链路

下面的程序实现日志中间件、鉴权中间件和状态码包装器。第一次请求没有令牌,会在鉴权层短路;第二次请求通过鉴权,才会进入业务处理器。httptest.NewServer 让示例无需手工占用固定端口即可运行。

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

预期输出

text
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),鉴权失败会在进入日志中间件前结束,日志层看不到这次请求。缓存、压缩、恢复、鉴权和指标也都有类似的顺序效应。

因此不要把中间件列表当成“无序插件集合”。先明确谁必须观察所有请求、谁允许短路、谁依赖前一层写入的上下文,再决定组合顺序,并用至少一条成功路径和一条短路路径做验证。

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

目录与阅读设置

阅读设置

17

记录一个想法

构建中间件链

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

登录哪都通