Golang中net/http包的超时设置详解

在Go语言的net/http包中，http.Client.Timeout确实覆盖了整个HTTP请求的生命周期，包括连接建立、重定向和响应体读取。对于需要更细粒度控制的场景，比如限制连接空闲时间或确保最低传输速率，可以通过自定义http.Transport来实现。以下是一个示例，展示如何设置连接超时、TLS握手超时和响应头超时，并监控空闲连接。

首先，创建一个自定义的http.Transport，设置相关超时参数：

package main

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

func main() {
    // 定义自定义传输层配置
    transport := &http.Transport{
        DialContext: (&net.Dialer{
            Timeout:   30 * time.Second, // 连接建立超时
            KeepAlive: 30 * time.Second, // 保持连接存活时间
        }).DialContext,
        TLSHandshakeTimeout:   10 * time.Second, // TLS握手超时
        ResponseHeaderTimeout: 10 * time.Second, // 响应头读取超时
        IdleConnTimeout:       30 * time.Second, // 空闲连接超时
        ExpectContinueTimeout: 1 * time.Second,  // Expect: 100-continue 超时
    }

    // 创建HTTP客户端，使用自定义传输层并设置整体超时（可选）
    client := &http.Client{
        Transport: transport,
        Timeout:   60 * time.Second, // 整体请求超时，覆盖整个操作
    }

    // 示例：发起HTTP GET请求
    req, err := http.NewRequestWithContext(context.Background(), "GET", "https://httpbin.org/delay/5", nil)
    if err != nil {
        fmt.Printf("Error creating request: %v\n", err)
        return
    }

    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Request failed: %v\n", err)
        return
    }
    defer resp.Body.Close()

    fmt.Printf("Response status: %s\n", resp.Status)
}

在这个示例中：

• DialContext.Timeout 设置了TCP连接建立的超时时间（例如30秒）。
• TLSHandshakeTimeout 控制了TLS握手过程的超时（例如10秒）。
• ResponseHeaderTimeout 指定了从连接建立到接收到响应头的最大时间（例如10秒）。
• IdleConnTimeout 管理连接池中空闲连接的存活时间（例如30秒），超过后连接会被关闭。
• ExpectContinueTimeout 用于处理带有"Expect: 100-continue"头的请求超时。

对于更高级的场景，如基于比特率的超时或动态空闲检测，可以通过包装http.RoundTripper接口实现自定义逻辑。以下是一个简单示例，监控响应体的读取速率，如果速率低于阈值则超时：

type rateLimitingTransport struct {
    transport http.RoundTripper
    minRate   int64 // 最小比特率，单位：字节/秒
}

func (t *rateLimitingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    resp, err := t.transport.RoundTrip(req)
    if err != nil {
        return nil, err
    }

    // 包装响应体以监控读取速率
    resp.Body = &rateLimitedReadCloser{
        ReadCloser: resp.Body,
        minRate:    t.minRate,
        startTime:  time.Now(),
    }
    return resp, nil
}

type rateLimitedReadCloser struct {
    io.ReadCloser
    minRate   int64
    startTime time.Time
    bytesRead int64
}

func (r *rateLimitedReadCloser) Read(p []byte) (n int, err error) {
    n, err = r.ReadCloser.Read(p)
    if n > 0 {
        r.bytesRead += int64(n)
        elapsed := time.Since(r.startTime).Seconds()
        currentRate := float64(r.bytesRead) / elapsed
        if currentRate < float64(r.minRate) && elapsed > 5.0 { // 至少5秒后检查
            return 0, fmt.Errorf("read rate too low: %.2f bytes/sec, min required: %d", currentRate, r.minRate)
        }
    }
    return n, err
}

// 使用自定义传输层
func main() {
    baseTransport := &http.Transport{
        DialContext: (&net.Dialer{
            Timeout: 30 * time.Second,
        }).DialContext,
    }
    customTransport := &rateLimitingTransport{
        transport: baseTransport,
        minRate:   1024, // 设置最小比特率为1 KB/秒
    }

    client := &http.Client{
        Transport: customTransport,
    }

    resp, err := client.Get("https://httpbin.org/stream-bytes/10240") // 示例端点，流式返回数据
    if err != nil {
        fmt.Printf("Request failed: %v\n", err)
        return
    }
    defer resp.Body.Close()

    // 读取响应体，如果速率低于minRate，会返回错误
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Error reading body: %v\n", err)
        return
    }
    fmt.Printf("Read %d bytes\n", len(body))
}

在这个高级示例中：

• rateLimitingTransport 包装了基础的http.RoundTripper，在响应体读取时监控比特率。
• rateLimitedReadCloser 实现了io.ReadCloser接口，在每次读取时计算当前平均速率，如果低于设定阈值（例如1 KB/秒）且经过一定时间（例如5秒），则返回错误。

通过这种方式，您可以实现更灵活的超时控制，适应长时运行请求或低带宽环境。注意，这些自定义逻辑可能会增加复杂性和性能开销，建议根据实际需求调整参数。