目录
- 引言：什么是 HTTP 中间件？
- Go 原生 HTTP Handler 与中间件概念
2.1.http.Handler与http.HandlerFunc
2.2. 中间件本质：高阶函数的应用 - 编写第一个简单中间件：请求日志
3.1. 代码示例：LoggerMiddleware
3.2. 图解：中间件链路执行流程 - 中间件链式组合与模式
4.1. 链式调用示意
4.2. 通用Use函数设计
4.3. 代码示例：链式中间件注册 - 常见实用中间件实现
5.1. 恢复（Recovery）中间件
5.2. 身份验证（Auth）中间件
5.3. 请求限流（Rate Limiting）中间件
5.4. Gzip 压缩中间件 - 提升中间件性能与最佳实践
6.1. 减少不必要的内存分配
6.2. 结合上下文（Context）传递参数
6.3. 将复杂逻辑放到异步或后端队列
6.4. 使用标准库http.ServeMux与第三方路由器对比 - 完整示例：实战演练
7.1. 项目结构概览
7.2. 实现入口文件main.go
7.3. 编写中间件包middleware/
7.4. 测试与验证效果 - 小结
1. 引言：什么是 HTTP 中间件？
在现代 Web 开发中，中间件（Middleware） 扮演着极其重要的角色。它位于请求和最终业务处理函数之间，为 HTTP 请求提供统一的预处理（如身份校验、日志、限流、CORS 处理等）和后处理（如结果格式化、压缩、异常恢复等）功能，从而实现代码的 横切关注点（Cross-cutting Concerns）分离。
- 预处理：在到达最终业务 Handler 之前，对请求进行检查、修改或拦截。
- 后处理：在业务 Handler 完成后，对响应结果进行包装、压缩或记录等。
具体到 Go 语言，HTTP 中间件通常以 高阶函数（Higher-order Function）的形式实现，通过传入并返回 http.Handler 或 http.HandlerFunc 来完成 Request-Response 的拦截与增强。
2. Go 原生 HTTP Handler 与中间件概念
2.1 http.Handler 与 http.HandlerFunc
在 Go 标准库 net/http 中，定义了如下两个核心接口／类型：
// Handler 定义
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
// HandlerFunc 将普通函数适配为 Handler
type HandlerFunc func(ResponseWriter, *Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}任意满足 ServeHTTP(http.ResponseWriter, *http.Request) 签名的函数，都可以通过 http.HandlerFunc 转换为 http.Handler，从而被 http.Server 使用。例如：
func helloHandler(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello, World!"))
}
http.Handle("/hello", http.HandlerFunc(helloHandler))2.2 中间件本质：高阶函数的应用
中间件（Middleware）在 Go 中的常见实现模式，就是接受一个 http.Handler，并返回一个新的 http.Handler，在新 Handler 内部先做一些额外逻辑，再调用原始 Handler。示意代码如下：
// Middleware 定义：接受一个 Handler 并返回一个 Handler
type Middleware func(http.Handler) http.Handler- 当我们需要为多个路由或 Handler 添加相同功能时，只需将它们 包裹（Wrap） 在中间件函数中即可。这种方式简洁、易组合，且遵循“开闭原则”：无需修改原业务 Handler 即可扩展功能。
3. 编写第一个简单中间件：请求日志
下面通过一个 请求日志 中间件示例，演示中间件的基本结构与使用方式。
3.1 代码示例：LoggerMiddleware
package middleware
import (
"log"
"net/http"
"time"
)
/*
LoggerMiddleware 是一个简单的中间件，用于在请求进入业务 Handler 之前，
输出请求方法、URL、处理耗时等日志信息。
*/
func LoggerMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
// 在请求到达 Handler 之前打印日志
log.Printf("Started %s %s", r.Method, r.RequestURI)
// 调用下一个 Handler
next.ServeHTTP(w, r)
// Handler 执行完毕后打印耗时
duration := time.Since(start)
log.Printf("Completed %s %s in %v", r.Method, r.RequestURI, duration)
})
}LoggerMiddleware函数接受原始的http.Handler，并返回一个新的http.HandlerFunc。- “前处理”在调用
next.ServeHTTP之前打印开始日志；“后处理”在调用后打印耗时。
3.2 图解：中间件链路执行流程
下面用 Mermaid 绘制调用链时序图，展示请求从客户端到业务 Handler 的流向，以及日志中间件的前后处理。
sequenceDiagram
participant Client as 客户端
participant Middleware as LoggerMiddleware
participant Handler as 业务 Handler
Client->>Middleware: HTTP Request (e.g., GET /users)
Note right of Middleware: 前处理：record start time, log "Started GET /users"
Middleware->>Handler: next.ServeHTTP(w, r)
Handler-->>Middleware: 业务处理完成，写入响应 (e.g., JSON)
Note right of Middleware: 后处理：计算耗时, log "Completed GET /users in 2.3ms"
Middleware-->>Client: HTTP Response- 前处理阶段：在调用
next.ServeHTTP之前，记录开始时间并输出日志。 - 业务处理阶段：调用原业务 Handler，执行业务逻辑、写入响应。
- 后处理阶段：业务完成后，计算耗时并输出日志，然后返回响应给客户端。
4. 中间件链式组合与模式
在实际项目中，往往存在多个中间件需要组合使用，比如日志、限流、身份验证等。我们需要一种通用机制来按顺序将它们串联起来。
4.1 链式调用示意
当有多个中间件 m1, m2, m3，以及最终业务 Handler h，它们的调用关系如下：
flowchart LR
subgraph Middleware Chain
direction LR
M1[Logger] --> M2[Recovery]
M2 --> M3[Auth]
M3 --> H[Handler]
end
Client --> M1
H --> Response --> Client- 请求先进入 Logger，再进入 Recovery，然后 Auth，最后到达真正的业务 Handler。
- 如果某个中间件决定“拦截”或“提前返回”，则后续链路不再继续调用。
4.2 通用 Use 函数设计
下面示例一个通用的 Use 函数，将若干中间件和业务 Handler 进行组合：
package middleware
import "net/http"
// Use 将 chain 列表中的中间件按顺序包裹到 final handler 上，返回一个新的 Handler
func Use(finalHandler http.Handler, chain ...func(http.Handler) http.Handler) http.Handler {
// 反向遍历 chain，将 finalHandler 包裹在最里面
for i := len(chain) - 1; i >= 0; i-- {
finalHandler = chain[i](finalHandler)
}
return finalHandler
}chain是一个func(http.Handler) http.Handler的数组。- 从最后一个中间件开始包裹，使得
chain[0]最先被调用。
4.3 代码示例：链式中间件注册
假设我们有三个中间件：LoggerMiddleware、RecoveryMiddleware 和 AuthMiddleware，以及一个用户业务 Handler UserHandler。我们可以这样注册路由：
package main
import (
"net/http"
"github.com/your/repo/middleware"
)
// UserHandler: 示例业务 Handler
func UserHandler(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("User info response"))
}
func main() {
finalHandler := http.HandlerFunc(UserHandler)
// 链式注册：先 Logger，再 Recovery，再 Auth，最后 UserHandler
chained := middleware.Use(finalHandler,
middleware.LoggerMiddleware,
middleware.RecoveryMiddleware,
middleware.AuthMiddleware,
)
http.Handle("/user", chained)
http.ListenAndServe(":8080", nil)
}- 最终请求
/user时，将依次经过三层中间件，最后才到UserHandler。 - 如果某个中间件（如
AuthMiddleware）检测到身份验证失败，可直接w.WriteHeader(http.StatusUnauthorized)并return，此时后续链路（UserHandler）不会执行。
5. 常见实用中间件实现
下面展示几个常见且实用的中间件示例，帮助你快速落地。
5.1 恢复（Recovery）中间件
当业务 Handler 内抛出 panic 时，如果不做处理，将导致整个进程崩溃。RecoveryMiddleware 通过捕获 panic，向客户端返回 500 错误，并记录错误日志。
package middleware
import (
"log"
"net/http"
)
/*
RecoveryMiddleware 捕获后续 Handler 的 panic，避免程序崩溃，
并返回 500 Internal Server Error。
*/
func RecoveryMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
log.Printf("Panic recovered: %v", err)
http.Error(w, "Internal Server Error", http.StatusInternalServerError)
}
}()
next.ServeHTTP(w, r)
})
}defer+recover()：在请求处理过程中捕获任何 panic。- 捕获后记录日志，并用
http.Error向客户端返回 500 状态码。
5.2 身份验证（Auth）中间件
示例中采用 HTTP Header 中的 Authorization 字段做简单演示，真实项目中可扩展为 JWT、OAuth2 等验证方式。
package middleware
import (
"net/http"
"strings"
)
/*
AuthMiddleware 从 Header 中提取 Authorization，验证是否有效，
若无效则返回 401，若有效则将用户信息放入 Context 传递给下游 Handler。
*/
// 假设 validToken = "Bearer secrettoken"
const validToken = "Bearer secrettoken"
// AuthMiddleware 简单示例
func AuthMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
authHeader := r.Header.Get("Authorization")
if authHeader == "" || !strings.HasPrefix(authHeader, validToken) {
http.Error(w, "Unauthorized", http.StatusUnauthorized)
return
}
// 若需要向下游传递用户信息，可使用 Context
ctx := r.Context()
ctx = context.WithValue(ctx, "user", "admin") // 示例存入用户名
next.ServeHTTP(w, r.WithContext(ctx))
})
}- 检查
Authorization是否以Bearer secrettoken开头，否则返回 401。 - 使用
context.WithValue将用户信息注入到*http.Request的 Context 中，供下游 Handler 读取。
5.3 请求限流（Rate Limiting）中间件
限流中间件常见实现方式包括 Token Bucket、Leaky Bucket、滑动窗口等，这里演示一个简单的漏桶算法（Leaky Bucket）限流。
package middleware
import (
"net/http"
"sync"
"time"
)
type rateLimiter struct {
capacity int // 桶容量
remaining int // 当前剩余令牌数
fillInterval time.Duration // 每次补充间隔
mu sync.Mutex
}
// NewRateLimiter 构造一个容量为 capacity、每 interval 补充 1 个令牌的限流器
func NewRateLimiter(capacity int, interval time.Duration) *rateLimiter {
rl := &rateLimiter{
capacity: capacity,
remaining: capacity,
fillInterval: interval,
}
go rl.refill() // 启动后台协程定期补充令牌
return rl
}
func (rl *rateLimiter) refill() {
ticker := time.NewTicker(rl.fillInterval)
defer ticker.Stop()
for {
<-ticker.C
rl.mu.Lock()
if rl.remaining < rl.capacity {
rl.remaining++
}
rl.mu.Unlock()
}
}
// Allow 尝试获取一个令牌，成功返回 true，否则 false
func (rl *rateLimiter) Allow() bool {
rl.mu.Lock()
defer rl.mu.Unlock()
if rl.remaining > 0 {
rl.remaining--
return true
}
return false
}
// RateLimitMiddleware 使用漏桶算法限流
func RateLimitMiddleware(limit *rateLimiter) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !limit.Allow() {
http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
return
}
next.ServeHTTP(w, r)
})
}
}rateLimiter维护桶容量、剩余令牌数，每隔fillInterval补充 1 个令牌。- 中间件在请求到达时调用
Allow()，无令牌则返回429 Too Many Requests。 - 实际项目中可按 IP 或用户维度创建多个
rateLimiter，实现更精细的限流策略。
5.4 Gzip 压缩中间件
对于需要传输大文本或 JSON 的接口，启用 Gzip 压缩可以减少网络带宽。示例使用 compress/gzip：
package middleware
import (
"compress/gzip"
"io"
"net/http"
"strings"
)
// GzipResponseWriter 包装 http.ResponseWriter，支持压缩写入
type GzipResponseWriter struct {
io.Writer
http.ResponseWriter
}
func (w GzipResponseWriter) Write(b []byte) (int, error) {
return w.Writer.Write(b)
}
// GzipMiddleware 在客户端支持 gzip 时对响应进行压缩
func GzipMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// 检查客户端是否支持 gzip
if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
next.ServeHTTP(w, r)
return
}
// 设置响应头
w.Header().Set("Content-Encoding", "gzip")
// gzip.Writer 会对底层 w 进行压缩
gz := gzip.NewWriter(w)
defer gz.Close()
// 用 GzipResponseWriter 包装原始 ResponseWriter
gzWriter := GzipResponseWriter{Writer: gz, ResponseWriter: w}
next.ServeHTTP(gzWriter, r)
})
}- 客户端需在请求头
Accept-Encoding中包含gzip，服务端才对响应进行压缩。 - 将原始
http.ResponseWriter包装为GzipResponseWriter，在Write时自动压缩后写入。 - 不支持
gzip的客户端则直接调用next.ServeHTTP，返回原始响应。
6. 提升中间件性能与最佳实践
在中间件的具体实现中，有些细节会影响性能和可维护性，下面列举几点经验供参考。
6.1 减少不必要的内存分配
尽量重用已有对象
- 请求日志中，可以将格式化字符串缓存或预分配缓冲区；
- 大量 JSON 序列化/反序列化时可使用
sync.Pool缓存bytes.Buffer实例，避免频繁分配。
避免中间件链中重复包装
- 使用
Use函数一次性将中间件与业务 Handler 包裹好，避免在每次路由匹配时都重新组合链路。
- 使用
var handlerChain http.Handler
func init() {
basicHandler := http.HandlerFunc(MyBizHandler)
handlerChain = middleware.Use(
basicHandler,
middleware.LoggerMiddleware,
middleware.RecoveryMiddleware,
middleware.AuthMiddleware,
middleware.GzipMiddleware,
)
}
func main() {
http.Handle("/api", handlerChain)
http.ListenAndServe(":8080", nil)
}6.2 结合上下文（Context）传递参数
Go 的 context.Context 是在请求链路中传递请求级别数据的首选方式：
- 身份认证：将用户信息存入
Context，下游 Handler 直接从ctx.Value("user")获取； - 请求超时/取消：通过
context.WithTimeout设置请求超时，Handler 可通过ctx.Done()监听取消信号。
func AuthMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
token := r.Header.Get("Authorization")
if !validateToken(token) {
http.Error(w, "Unauthorized", http.StatusUnauthorized)
return
}
userID := extractUserID(token)
ctx := context.WithValue(r.Context(), "userID", userID)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
func MyBizHandler(w http.ResponseWriter, r *http.Request) {
userID := r.Context().Value("userID").(string)
// 根据 userID 处理业务
w.Write([]byte(fmt.Sprintf("Hello, user %s", userID)))
}6.3 将复杂逻辑放到异步或后端队列
- 限流、黑名单检查等热点逻辑可将数据结构驻留在本地内存（同步安全），减少阻塞；
- 对于写操作较多的场景（如日志落盘、审计写库），可将它们推送到 异步 Channel 或消息队列，让请求快速返回，后端消费者再做真正的写入。
// 日志异步落盘示例
var logChan = make(chan string, 1000)
func init() {
go func() {
for entry := range logChan {
// 写入文件或数据库
saveLog(entry)
}
}()
}
func LoggerMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
entry := fmt.Sprintf("Started %s %s", r.Method, r.RequestURI)
select {
case logChan <- entry:
default:
// 日志队列满时丢弃或落盘到本地文件
}
next.ServeHTTP(w, r)
})
}6.4 使用标准库 http.ServeMux 与第三方路由器对比
- Go 标准库自带
http.ServeMux功能简单、轻量；但不支持路由参数、分组等高级特性。 - 常用第三方路由框架：
gorilla/mux、httprouter、chi、echo、gin等，可搭配中间件链使用。例如gin内置了链式中间件机制，只需调用router.Use(...)即可。
// gin 示例
r := gin.Default() // Default 已经注册了 Logger & Recovery
r.Use(AuthMiddlewareGin())
r.GET("/user/:id", func(c *gin.Context) {
id := c.Param("id")
c.JSON(200, gin.H{"user": id})
})
r.Run(":8080")7. 完整示例：实战演练
下面以一个综合示例展示项目整体结构与各部分代码，帮助你快速复现上述思路。
7.1 项目结构概览
go-http-middleware-demo/
├── go.mod
├── main.go
├── middleware
│ ├── logger.go
│ ├── recovery.go
│ ├── auth.go
│ ├── ratelimit.go
│ └── gzip.go
└── handler
└── user.go7.2 实现入口文件 main.go
package main
import (
"net/http"
"github.com/your/repo/middleware"
"github.com/your/repo/handler"
)
func main() {
// 1. 业务 Handler
userHandler := http.HandlerFunc(handler.UserHandler)
// 2. 限流器示例：容量 5，每秒补充 1 个令牌
rateLimiter := middleware.NewRateLimiter(5, time.Second)
// 3. 链式组合中间件
finalHandler := middleware.Use(userHandler,
middleware.LoggerMiddleware,
middleware.RecoveryMiddleware,
middleware.AuthMiddleware,
middleware.RateLimitMiddleware(rateLimiter),
middleware.GzipMiddleware,
)
http.Handle("/user", finalHandler)
http.ListenAndServe(":8080", nil)
}- 我们将所有中间件按顺序组合，形成最终 Handler
finalHandler，并注册到/user路由。 - 启动服务后，请求
/user将经历 Logger → Recovery → Auth → RateLimit → Gzip → UserHandler 这 6 道“关卡”。
7.3 编写中间件包 middleware/
logger.go
package middleware
import (
"log"
"net/http"
"time"
)
func LoggerMiddleware(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.RequestURI)
next.ServeHTTP(w, r)
duration := time.Since(start)
log.Printf("Completed %s %s in %v", r.Method, r.RequestURI, duration)
})
}recovery.go
package middleware
import (
"log"
"net/http"
)
func RecoveryMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
log.Printf("Panic recovered: %v", err)
http.Error(w, "Internal Server Error", http.StatusInternalServerError)
}
}()
next.ServeHTTP(w, r)
})
}auth.go
package middleware
import (
"context"
"net/http"
"strings"
)
const validToken = "Bearer secrettoken"
func AuthMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
authHeader := r.Header.Get("Authorization")
if authHeader == "" || !strings.HasPrefix(authHeader, validToken) {
http.Error(w, "Unauthorized", http.StatusUnauthorized)
return
}
ctx := context.WithValue(r.Context(), "user", "admin")
next.ServeHTTP(w, r.WithContext(ctx))
})
}ratelimit.go
package middleware
import (
"net/http"
"sync"
"time"
)
type rateLimiter struct {
capacity int
remaining int
fillInterval time.Duration
mu sync.Mutex
}
func NewRateLimiter(capacity int, interval time.Duration) *rateLimiter {
rl := &rateLimiter{
capacity: capacity,
remaining: capacity,
fillInterval: interval,
}
go rl.refill()
return rl
}
func (rl *rateLimiter) refill() {
ticker := time.NewTicker(rl.fillInterval)
defer ticker.Stop()
for {
<-ticker.C
rl.mu.Lock()
if rl.remaining < rl.capacity {
rl.remaining++
}
rl.mu.Unlock()
}
}
func (rl *rateLimiter) Allow() bool {
rl.mu.Lock()
defer rl.mu.Unlock()
if rl.remaining > 0 {
rl.remaining--
return true
}
return false
}
func RateLimitMiddleware(limit *rateLimiter) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !limit.Allow() {
http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
return
}
next.ServeHTTP(w, r)
})
}
}gzip.go
package middleware
import (
"compress/gzip"
"io"
"net/http"
"strings"
)
type GzipResponseWriter struct {
io.Writer
http.ResponseWriter
}
func (w GzipResponseWriter) Write(b []byte) (int, error) {
return w.Writer.Write(b)
}
func GzipMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
next.ServeHTTP(w, r)
return
}
w.Header().Set("Content-Encoding", "gzip")
gz := gzip.NewWriter(w)
defer gz.Close()
gzWriter := GzipResponseWriter{Writer: gz, ResponseWriter: w}
next.ServeHTTP(gzWriter, r)
})
}7.4 编写业务 Handler handler/user.go
package handler
import (
"encoding/json"
"net/http"
)
type UserInfo struct {
ID string `json:"id"`
Name string `json:"name"`
}
func UserHandler(w http.ResponseWriter, r *http.Request) {
// 从 Context 中获取 user（由 AuthMiddleware 注入）
user := r.Context().Value("user").(string)
info := UserInfo{
ID: "12345",
Name: user,
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(info)
}- 该 Handler 从 Context 中读取
user（由 AuthMiddleware 注入），并返回一个 JSON 格式的用户信息。
7.5 测试与验证效果
启动服务
go run main.go模拟请求
使用
curl测试各中间件的效果：缺少 Token，AuthMiddleware 拦截：
$ curl -i http://localhost:8080/user HTTP/1.1 401 Unauthorized Date: Tue, 10 Sep 2023 10:00:00 GMT Content-Length: 12 Content-Type: text/plain; charset=utf-8 Unauthorized合法 Token，查看日志、限流、Gzip 效果：
$ curl -i -H "Authorization: Bearer secrettoken" -H "Accept-Encoding: gzip" http://localhost:8080/user HTTP/1.1 200 OK Content-Encoding: gzip Content-Type: application/json Date: Tue, 10 Sep 2023 10:00:05 GMT Content-Length: 45 <gzip 压缩后的响应体>超过限流阈值，RateLimitMiddleware 返回 429：
$ for i in {1..10}; do \ curl -i -H "Authorization: Bearer secrettoken" http://localhost:8080/user; \ done HTTP/1.1 200 OK ... // 前 5 次正常 HTTP/1.1 429 Too Many Requests Date: Tue, 10 Sep 2023 10:00:06 GMT Content-Length: 18 Content-Type: text/plain; charset=utf-8 Too Many Requests模拟 Panic，RecoveryMiddleware 捕获并返回 500：
在
handler/user.go临时加入panic("unexpected error")，查看响应：$ curl -i -H "Authorization: Bearer secrettoken" http://localhost:8080/user HTTP/1.1 500 Internal Server Error Date: Tue, 10 Sep 2023 10:00:07 GMT Content-Length: 21 Content-Type: text/plain; charset=utf-8 Internal Server Error- 查看控制台日志，可以看到 LoggerMiddleware 打印的开始与完成日志，以及 RecoveryMiddleware 捕获的 Panic 日志。
8. 小结
本文系统地介绍了 Go 语言实战：打造高效 HTTP 中间件 的思路与实现，包括：
中间件概念与 Go 实现方式
- 以
http.Handler和高阶函数为基础，将“预处理”和“后处理”逻辑提取为可复用的中间件。
- 以
第一个 Logger 中间件示例
- 详细讲解了如何记录请求开始与结束时长，并用 Mermaid 图解展示中间件链路顺序。
链式中间件组合模式
- 封装通用
Use函数，实现多个中间件在注册时按顺序包裹业务 Handler。
- 封装通用
常见实用中间件
- Recovery：防止 panic 导致进程崩溃，优雅返回 500。
- Auth：从 Header 中提取 Token 并将用户信息注入
Context。 - Rate Limit：基于漏桶算法实现简单的限流。
- Gzip：根据客户端支持情况对响应进行 Gzip 压缩。
性能与最佳实践
- 减少内存分配及链路重复包装，善用
context.Context传递请求级别数据，将耗时操作放到异步流程。 - 对比标准库路由与第三方框架（如 Gin）在中间件机制上的差异与优势。
- 减少内存分配及链路重复包装，善用
完整项目示例
- 提供一个完整可运行的示例项目，包括目录结构、代码、测试步骤，让你可以快速复现并检验各中间件的效果。
通过本文示例与细节说明，你应该能掌握 如何在 Go 中灵活地设计与编写 HTTP 中间件，并在实际项目中根据业务需求快速组合、扩展与优化，提高代码可维护性与性能。