Go语言实战：打造高效HTTP中间件‌

目录

1. 引言：什么是 HTTP 中间件？
2. Go 原生 HTTP Handler 与中间件概念
   2.1. http.Handler 与 http.HandlerFunc
   2.2. 中间件本质：高阶函数的应用
3. 编写第一个简单中间件：请求日志
   3.1. 代码示例：LoggerMiddleware
   3.2. 图解：中间件链路执行流程
4. 中间件链式组合与模式
   4.1. 链式调用示意
   4.2. 通用 Use 函数设计
   4.3. 代码示例：链式中间件注册
5. 常见实用中间件实现
   5.1. 恢复（Recovery）中间件
   5.2. 身份验证（Auth）中间件
   5.3. 请求限流（Rate Limiting）中间件
   5.4. Gzip 压缩中间件
6. 提升中间件性能与最佳实践
   6.1. 减少不必要的内存分配
   6.2. 结合上下文（Context）传递参数
   6.3. 将复杂逻辑放到异步或后端队列
   6.4. 使用标准库 http.ServeMux 与第三方路由器对比
7. 完整示例：实战演练
   7.1. 项目结构概览
   7.2. 实现入口文件 main.go
   7.3. 编写中间件包 middleware/
   7.4. 测试与验证效果
8. 小结

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 减少不必要的内存分配

1. 尽量重用已有对象

   • 请求日志中，可以将格式化字符串缓存或预分配缓冲区；
   • 大量 JSON 序列化/反序列化时可使用 sync.Pool 缓存 bytes.Buffer 实例，避免频繁分配。

2. 避免中间件链中重复包装

   • 使用 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.go

7.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 测试与验证效果

1. 启动服务

   go run main.go

2. 模拟请求

   使用 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 中间件 的思路与实现，包括：

1. 中间件概念与 Go 实现方式

   • 以 http.Handler 和高阶函数为基础，将“预处理”和“后处理”逻辑提取为可复用的中间件。

2. 第一个 Logger 中间件示例

   • 详细讲解了如何记录请求开始与结束时长，并用 Mermaid 图解展示中间件链路顺序。

3. 链式中间件组合模式

   • 封装通用 Use 函数，实现多个中间件在注册时按顺序包裹业务 Handler。

4. 常见实用中间件

   • Recovery：防止 panic 导致进程崩溃，优雅返回 500。
   • Auth：从 Header 中提取 Token 并将用户信息注入 Context。
   • Rate Limit：基于漏桶算法实现简单的限流。
   • Gzip：根据客户端支持情况对响应进行 Gzip 压缩。

5. 性能与最佳实践

   • 减少内存分配及链路重复包装，善用 context.Context 传递请求级别数据，将耗时操作放到异步流程。
   • 对比标准库路由与第三方框架（如 Gin）在中间件机制上的差异与优势。

6. 完整项目示例

   • 提供一个完整可运行的示例项目，包括目录结构、代码、测试步骤，让你可以快速复现并检验各中间件的效果。

通过本文示例与细节说明，你应该能掌握 如何在 Go 中灵活地设计与编写 HTTP 中间件，并在实际项目中根据业务需求快速组合、扩展与优化，提高代码可维护性与性能。