Go 网络问题：HTTP 请求超时与重试

网络环境的不稳定是后端开发中必须面对的常态。在 Go 语言中，默认的 HTTP 客户端（http.Client）如果不进行任何配置，既没有超时机制，也没有自动重试功能。这会导致在服务端响应缓慢或网络抖动时，请求长时间挂起，最终耗尽系统的文件描述符或连接池资源。

本指南将带你一步步配置合理的超时策略，并实现带有指数退避的重试机制。

第一阶段：配置基础超时

解决 HTTP 请求挂起的最直接方法是设置总超时时间。这确保了无论请求因何原因受阻，都会在指定时间内终止。

1. 创建 自定义的 http.Client 对象。
2. 设置 Timeout 字段，该字段涵盖了从请求发出到响应体读取完毕的全过程。

执行以下代码创建一个带有 5 秒超时的客户端：

package main

import (
    "fmt"
    "net/http"
    "time"
)

func main() {
    // 创建自定义客户端
    client := &http.Client{
        Timeout: 5 * time.Second, // 设置总超时时间为 5 秒
    }

    // 发起请求
    resp, err := client.Get("https://example.com")
    if err != nil {
        fmt.Printf("请求失败: %v\n", err)
        return
    }
    defer resp.Body.Close()

    fmt.Printf("请求成功，状态码: %d\n", resp.StatusCode)
}

虽然这解决了“无限等待”的问题，但在复杂场景下，你可能需要对连接、传输头部等不同阶段进行更精细的控制。

第二阶段：细粒度超时控制

为了应对“慢速攻击”或特定阶段的网络阻塞，配置 http.Transport 结构体，分别控制不同阶段的超时。

1. 定义 http.Transport 结构体，并设置其内部超时参数。
2. 注入 该结构体到 http.Client 中。

以下是常用超时参数的对比与配置：

执行以下代码实现细粒度控制：

package main

import (
    "net"
    "net/http"
    "time"
)

func createClient() *http.Client {
    transport := &http.Transport{
        // 建立 TCP 连接的超时时间
        DialContext: (&net.Dialer{
            Timeout:   3 * time.Second,
            KeepAlive: 30 * time.Second,
        }).DialContext,
        // 等待服务端响应头的超时时间
        ResponseHeaderTimeout: 2 * time.Second,
        // 空闲连接超时时间
        IdleConnTimeout: 90 * time.Second,
        // 期望服务端响应的最大时长（包含 body）
        // 注意：若 Client 设置了 Timeout，此参数通常不需要单独设置
    }

    return &http.Client{
        Transport: transport,
        // 总体超时时间，覆盖所有阶段
        Timeout: 10 * time.Second,
    }
}

第三阶段：实现指数退避重试

网络抖动可能导致偶发性错误。对于非致命错误（如 5xx 服务端错误或网络偶发中断），实现自动重试机制至关重要。为防止重试风暴（在短时间内大量重试压垮服务），使用指数退避算法。

指数退避的计算公式如下：

$$ T_{wait} = \min(T_{max}, T_{base} \times 2^{n-1}) $$

其中：

• $T_{wait}$：本次重试前的等待时间。
• $T_{base}$：基础等待时间（如 100ms）。
• $n$：当前是第几次重试。
• $T_{max}$：最大等待时间上限。

1. 定义 重试策略（最大次数、基础等待时间）。
2. 编写 重试循环，捕获错误或特定状态码。
3. 计算 等待时间并休眠。

以下是重试逻辑的执行流程：

执行以下代码实现完整的重试机制：

package main

import (
    "fmt"
    "io"
    "math"
    "net/http"
    "time"
)

// HTTPClient 封装了标准库 Client，增加重试逻辑
type HTTPClient struct {
    client     *http.Client
    maxRetries int
    baseWait   time.Duration
    maxWait    time.Duration
}

func NewHTTPClient(maxRetries int, baseWait, maxWait time.Duration) *HTTPClient {
    return &HTTPClient{
        client: &http.Client{
            Timeout: 10 * time.Second,
        },
        maxRetries: maxRetries,
        baseWait:   baseWait,
        maxWait:    maxWait,
    }
}

func (c *HTTPClient) Do(req *http.Request) (*http.Response, error) {
    var resp *http.Response
    var err error

    for i := 0; i < c.maxRetries; i++ {
        // 发送请求
        resp, err = c.client.Do(req)

        // 如果没有错误，且状态码不是 5xx，视为成功，直接返回
        if err == nil && resp.StatusCode < 500 {
            return resp, nil
        }

        // 如果是最后一次循环，不再等待
        if i == c.maxRetries-1 {
            break
        }

        // 如果有响应体，先读取完并关闭，以便复用连接
        if resp != nil {
            io.Copy(io.Discard, resp.Body)
            resp.Body.Close()
        }

        // 计算指数退避时间
        // 公式：min(maxWait, baseWait * 2^i)
        waitTime := time.Duration(float64(c.baseWait) * math.Pow(2, float64(i)))
        if waitTime > c.maxWait {
            waitTime = c.maxWait
        }

        // 打印日志（生产环境建议替换为结构化日志库）
        fmt.Printf("请求失败 (尝试 %d/%d)，%v 后重试...\n", i+1, c.maxRetries, waitTime)

        // 等待后重试
        time.Sleep(waitTime)

        // 重置 Body 以便重试（针对 POST/PUT 请求，如果是 GET 可忽略）
        // 注意：这里假设 req.Body 支持 Seek 或者是 NoBody，
        // 对于真实的流式 Body 需要更复杂的处理逻辑（如重新构造 Body）。
        if req.Body != nil {
            // 简单示例中假设 Body 可重置或为 nil
            // 实际生产中可能需要重新创建 Reader
        }
    }

    return resp, err
}

func main() {
    client := NewHTTPClient(3, 100*time.Millisecond, 2*time.Second)

    req, _ := http.NewRequest("GET", "https://httpstat.us/503", nil)

    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("最终请求失败: %v\n", err)
        return
    }
    defer resp.Body.Close()

    fmt.Printf("请求成功: %d\n", resp.StatusCode)
}

第四阶段：结合 Context 实现主动取消

除了被动超时，应用程序经常需要主动取消请求（例如用户取消了前端操作）。Go 语言通过 context.Context 传递取消信号。

1. 创建 带有取消功能的 Context。
2. 绑定 Context 到 http.Request。
3. 调用 cancel 函数模拟外部取消。

执行以下代码测试取消逻辑：

package main

import (
    "context"
    "fmt"
    "net/http"
    "time"
)

func main() {
    // 创建一个会在 100毫秒 后自动取消的 Context
    ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel() // 确保资源释放

    req, _ := http.NewRequest("GET", "https://httpstat.us/200?sleep=2000", nil)
    // 将 Context 绑定到请求
    req = req.WithContext(ctx)

    client := &http.Client{}

    resp, err := client.Do(req)
    if err != nil {
        // 此时通常会报错：context deadline exceeded
        fmt.Printf("请求被取消或超时: %v\n", err)
        return
    }
    defer resp.Body.Close()

    fmt.Println("请求完成")
}

在此代码中，由于服务端模拟了 2000ms 的处理时间，而客户端 Context 仅在 100ms 后过期，因此请求会触发 context deadline exceeded 错误并立即返回，无需等待完整的 2 秒。这对于提升应用响应速度至关重要。