3. 流量录制基础：HTTP请求拦截原理与完整捕获

流量录制是回放工程的第一个关键环节，其核心在于完整、准确地捕获生产环境中的HTTP请求，包括请求行、请求头、请求体以及连接元数据。本章将深入Go语言生态下的HTTP请求拦截原理，并基于net/http/httptest库与中间件模式，实现一个生产可用的录制器。

3.1 HTTP请求拦截的两种核心模式

在Go服务中拦截HTTP请求，通常有两种架构模式：代理模式与中间件模式。两者在部署方式、性能开销和侵入性上存在显著差异。

3.2 net/http/httptest 库：请求捕获的基石

net/http/httptest是Go标准库提供的HTTP测试工具包，其核心组件ResponseRecorder实现了http.ResponseWriter接口，能够记录写入的响应状态码、Header和Body。在录制场景中，我们利用它来“嗅探”经过中间件的请求与响应。

以下是一个基于httptest.ResponseRecorder的请求捕获示例：

package recorder

import (
    "bytes"
    "io"
    "net/http"
    "net/http/httptest"
)

// CaptureRequest 使用httptest.ResponseRecorder捕获请求与响应
func CaptureRequest(handler http.Handler, req *http.Request) (*RecordedRequest, *RecordedResponse) {
    // 1. 读取并缓存请求体（请求体只能读取一次）
    bodyBytes, _ := io.ReadAll(req.Body)
    req.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))

    // 2. 创建ResponseRecorder
    w := httptest.NewRecorder()

    // 3. 执行原始handler
    handler.ServeHTTP(w, req)

    // 4. 构造录制对象
    recordedReq := &RecordedRequest{
        Method:     req.Method,
        URL:        req.URL.String(),
        Header:     req.Header.Clone(),
        Body:       bodyBytes,
        Host:       req.Host,
    }

    recordedResp := &RecordedResponse{
        StatusCode: w.Code,
        Header:     w.Header().Clone(),
        Body:       w.Body.Bytes(),
    }

    return recordedReq, recordedResp
}

type RecordedRequest struct {
    Method string
    URL    string
    Header http.Header
    Body   []byte
    Host   string
}

type RecordedResponse struct {
    StatusCode int
    Header     http.Header
    Body       []byte
}

3.3 中间件式录制器实现

基于Go的http.Handler包装模式，我们可以构建一个无侵入的录制中间件。该中间件在请求进入业务逻辑前完成捕获，并在响应返回后异步写入存储。

// RecorderMiddleware 返回一个录制中间件
func RecorderMiddleware(storage RecorderStorage) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            // 1. 读取并缓存请求体
            reqBody, _ := io.ReadAll(r.Body)
            r.Body = io.NopCloser(bytes.NewBuffer(reqBody))

            // 2. 使用ResponseRecorder包装原始ResponseWriter
            rec := httptest.NewRecorder()

            // 3. 执行下一个handler（业务逻辑）
            next.ServeHTTP(rec, r)

            // 4. 将原始ResponseWriter的响应写回客户端
            for k, v := range rec.Header() {
                w.Header()[k] = v
            }
            w.WriteHeader(rec.Code)
            w.Write(rec.Body.Bytes())

            // 5. 异步录制请求与响应
            go func() {
                record := &RequestRecord{
                    Request: &RecordedRequest{
                        Method: r.Method,
                        URL:    r.URL.String(),
                        Header: r.Header.Clone(),
                        Body:   reqBody,
                        Host:   r.Host,
                    },
                    Response: &RecordedResponse{
                        StatusCode: rec.Code,
                        Header:     rec.Header().Clone(),
                        Body:       rec.Body.Bytes(),
                    },
                }
                if err := storage.Save(record); err != nil {
                    // 生产环境应使用结构化日志记录错误
                    log.Printf("failed to save record: %v", err)
                }
            }()
        })
    }
}

// RecorderStorage 定义录制存储接口
type RecorderStorage interface {
    Save(record *RequestRecord) error
}

3.4 请求头/体/URL的完整捕获策略

要保证回放时的请求等价性，必须捕获以下三个维度的完整信息：

以下是一个完整的URL捕获示例，展示如何处理Query参数和Fragment：

// CaptureURL 捕获并标准化URL信息
func CaptureURL(r *http.Request) *CapturedURL {
    // 深拷贝URL对象，避免后续修改影响
    u := &url.URL{
        Scheme:   r.URL.Scheme,
        Opaque:   r.URL.Opaque,
        User:     r.URL.User,
        Host:     r.Host, // 使用r.Host而非r.URL.Host，确保包含端口
        Path:     r.URL.Path,
        RawPath:  r.URL.RawPath,
        RawQuery: r.URL.RawQuery,
        Fragment: r.URL.Fragment,
    }

    // 确保Query参数顺序一致
    q := u.Query()
    u.RawQuery = q.Encode()

    return &CapturedURL{
        FullURL:  u.String(),
        Path:     u.Path,
        RawQuery: u.RawQuery,
        Params:   q,
    }
}

type CapturedURL struct {
    FullURL  string
    Path     string
    RawQuery string
    Params   url.Values
}

3.5 流量录制架构总览

下图展示了基于中间件模式的流量录制整体架构，从请求进入、拦截捕获到异步存储的完整链路。

3.6 请求体捕获的边界情况处理

在实际生产环境中，请求体捕获需要处理多种边界情况。下表总结了常见场景及应对策略：

3.7 请求头捕获的过滤与标准化

并非所有请求头都适合直接录制。以下是一个请求头过滤器的实现，用于移除Hop-by-hop头和敏感信息：

// FilterHeaders 过滤并标准化请求头
func FilterHeaders(header http.Header) http.Header {
    filtered := header.Clone()

    // 移除Hop-by-hop头（这些头不应被代理转发）
    hopByHop := []string{
        "Connection",
        "Keep-Alive",
        "Proxy-Authenticate",
        "Proxy-Authorization",
        "Te",
        "Trailers",
        "Transfer-Encoding",
        "Upgrade",
    }
    for _, h := range hopByHop {
        filtered.Del(h)
    }

    // 移除敏感头
    sensitive := []string{
        "Authorization",
        "Cookie",
        "Set-Cookie",
        "X-Api-Key",
        "X-Auth-Token",
    }
    for _, h := range sensitive {
        filtered.Del(h)
    }

    // 标准化Content-Length（确保与实际Body长度一致）
    if bodyLen := len(filtered.Get("Content-Length")); bodyLen > 0 {
        // 实际长度在录制时由Body字节数决定，此处仅做标记
        filtered.Set("X-Recorded-Content-Length", filtered.Get("Content-Length"))
    }

    return filtered
}

3.8 录制器的性能基准与优化

在生产环境中，录制器必须满足高性能要求。以下是一个简单的基准测试结果（基于Go 1.21，8核CPU，16GB内存）：

优化建议：

• 内存复用：使用sync.Pool复用bytes.Buffer和httptest.ResponseRecorder对象，减少GC压力。
• 批量写入：存储层采用批量写入策略，每100条记录或每100ms刷盘一次，降低IO次数。
• 采样率控制：对于高QPS服务，支持配置采样率（如1/1000），仅录制部分请求以降低开销。

下图展示了录制器在请求处理管道中的精确位置与数据流向：

通过以上步骤，我们实现了一个完整的、生产可用的HTTP请求录制器。在下一阶段，我们将基于录制的流量数据，构建回放引擎的核心——请求匹配与响应比对逻辑。