transport := &http.Transport{
    DialContext: (&net.Dialer{
        Timeout:   3 * time.Second,  // TCP連接建立超時(shí)
        KeepAlive: 30 * time.Second, // 連接保活時(shí)間
        DualStack: true,             // 支持IPv4/IPv6雙棧
    }).DialContext,
    ResponseHeaderTimeout: 5 * time.Second, // 等待響應(yīng)頭超時(shí)
    MaxIdleConnsPerHost:   100,             // 每個(gè)主機(jī)的最大空閑連接
}
client := &http.Client{
    Transport: transport,
    Timeout:   10 * time.Second, // 整個(gè)請(qǐng)求的超時(shí)時(shí)間
}

func requestWithTracing(ctx context.Context) (*http.Response, error) {
    // 從父上下文派生5秒超時(shí)的子上下文
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel() // 確保無(wú)論成功失敗都取消上下文
    
    req, err := http.NewRequestWithContext(ctx, "GET", "https://api.example.com/data", nil)
    if err != nil {
        return nil, fmt.Errorf("創(chuàng)建請(qǐng)求失敗: %v", err)
    }
    
    // 添加分布式追蹤信息
    req.Header.Set("X-Request-ID", ctx.Value("request-id").(string))
    
    client := &http.Client{
        Transport: &http.Transport{
            DialContext: (&net.Dialer{
                Timeout: 2 * time.Second,
            }).DialContext,
        },
        // 注意: 此處不設(shè)置Timeout，完全由context控制
    }
    
    resp, err := client.Do(req)
    if err != nil {
        // 區(qū)分上下文取消和其他錯(cuò)誤
        if ctx.Err() == context.DeadlineExceeded {
            return nil, fmt.Errorf("請(qǐng)求超時(shí): %w", ctx.Err())
        }
        return nil, fmt.Errorf("請(qǐng)求失敗: %v", err)
    }
    return resp, nil
}

type RetryPolicy struct {
    MaxRetries    int
    InitialBackoff time.Duration
    MaxBackoff    time.Duration
    JitterFactor  float64 // 抖動(dòng)系數(shù)，建議0.1-0.5
}


// 帶抖動(dòng)的指數(shù)退避
func (rp *RetryPolicy) Backoff(attempt int) time.Duration {
    if attempt <= 0 {
        return rp.InitialBackoff
    }
    // 指數(shù)增長(zhǎng): InitialBackoff * 2^(attempt-1)
    backoff := rp.InitialBackoff * (1 << (attempt - 1))
    if backoff > rp.MaxBackoff {
        backoff = rp.MaxBackoff
    }
    // 添加抖動(dòng): [backoff*(1-jitter), backoff*(1+jitter)]
    jitter := time.Duration(rand.Float64() * float64(backoff) * rp.JitterFactor)
    return backoff - jitter + 2*jitter // 均勻分布在抖動(dòng)范圍內(nèi)
}


// 通用重試執(zhí)行器
func Retry(ctx context.Context, policy RetryPolicy, fn func() error) error {
    var err error
    for attempt := 0; attempt <= policy.MaxRetries; attempt++ {
        if attempt > 0 {
            // 檢查上下文是否已取消
            select {
            case <-ctx.Done():
                return fmt.Errorf("重試被取消: %w", ctx.Err())
            default:
            }
            
            backoff := policy.Backoff(attempt)
            timer := time.NewTimer(backoff)
            select {
            case <-timer.C:
            case <-ctx.Done():
                timer.Stop()
                return fmt.Errorf("重試被取消: %w", ctx.Err())
            }
        }
        
        err = fn()
        if err == nil {
            return nil
        }
        
        // 判斷是否應(yīng)該重試
        if !shouldRetry(err) {
            return err
        }
    }
    return fmt.Errorf("達(dá)到最大重試次數(shù) %d: %w", policy.MaxRetries, err)
}

func shouldRetry(err error) bool {
    // 網(wǎng)絡(luò)層面錯(cuò)誤
    var netErr net.Error
    if errors.As(err, &netErr) {
        // 超時(shí)錯(cuò)誤和臨時(shí)網(wǎng)絡(luò)錯(cuò)誤可重試
        return netErr.Timeout() || netErr.Temporary()
    }
    
    // HTTP狀態(tài)碼判斷
    var respErr *url.Error
    if errors.As(err, &respErr) {
        if resp, ok := respErr.Response.(*http.Response); ok {
            switch resp.StatusCode {
            case 429, 500, 502, 503, 504:
                return true // 限流和服務(wù)器錯(cuò)誤可重試
            case 408:
                return true // 請(qǐng)求超時(shí)可重試
            }
        }
    }
    
    // 應(yīng)用層自定義錯(cuò)誤
    if errors.Is(err, ErrRateLimited) || errors.Is(err, ErrServiceUnavailable) {
        return true
    }
    
    return false
}

type IdempotentClient struct {
    redisClient *redis.Client
    prefix      string        // Redis鍵前綴
    ttl         time.Duration // 冪等鍵過(guò)期時(shí)間
}


// 生成唯一請(qǐng)求ID
func (ic *IdempotentClient) NewRequestID() string {
    return uuid.New().String()
}


// 執(zhí)行冪等請(qǐng)求
func (ic *IdempotentClient) Do(req *http.Request, requestID string) (*http.Response, error) {
    // 檢查請(qǐng)求是否已處理
    key := fmt.Sprintf("%s:%s", ic.prefix, requestID)
    exists, err := ic.redisClient.Exists(req.Context(), key).Result()
    if err != nil {
        return nil, fmt.Errorf("冪等檢查失敗: %v", err)
    }
    if exists == 1 {
        // 返回緩存的響應(yīng)或標(biāo)記為重復(fù)請(qǐng)求
        return nil, fmt.Errorf("請(qǐng)求已處理: %s", requestID)
    }
    
    // 使用SET NX確保只有一個(gè)請(qǐng)求能通過(guò)檢查
    set, err := ic.redisClient.SetNX(
        req.Context(),
        key,
        "processing",
        ic.ttl,
    ).Result()
    if err != nil {
        return nil, fmt.Errorf("冪等鎖失敗: %v", err)
    }
    if !set {
        return nil, fmt.Errorf("并發(fā)請(qǐng)求沖突: %s", requestID)
    }
    
    // 執(zhí)行請(qǐng)求
    client := &http.Client{/* 配置 */}
    resp, err := client.Do(req)
    if err != nil {
        // 請(qǐng)求失敗時(shí)刪除冪等標(biāo)記
        ic.redisClient.Del(req.Context(), key)
        return nil, err
    }
    
    // 請(qǐng)求成功，更新冪等標(biāo)記狀態(tài)
    ic.redisClient.Set(req.Context(), key, "completed", ic.ttl)
    return resp, nil
}

func NewOptimizedTransport() *http.Transport {
    return &http.Transport{
        // 連接池配置
        MaxIdleConns:        1000,  // 全局最大空閑連接
        MaxIdleConnsPerHost: 100,   // 每個(gè)主機(jī)的最大空閑連接
        IdleConnTimeout:     90 * time.Second, // 空閑連接超時(shí)時(shí)間
        
        // TCP配置
        DialContext: (&net.Dialer{
            Timeout:   2 * time.Second,
            KeepAlive: 30 * time.Second,
        }).DialContext,
        
        // TLS配置
        TLSHandshakeTimeout: 5 * time.Second,
        TLSClientConfig: &tls.Config{
            InsecureSkipVerify: false,
            MinVersion:         tls.VersionTLS12,
        },
        
        // 其他優(yōu)化
        ExpectContinueTimeout: 1 * time.Second,
        DisableCompression:    false, // 啟用壓縮
    }
}

var requestPool = sync.Pool{
    New: func() interface{} {
        return &http.Request{
            Header: make(http.Header),
        }
    },
}


// 從池獲取請(qǐng)求對(duì)象
func AcquireRequest() *http.Request {
    req := requestPool.Get().(*http.Request)
    // 重置必要字段
    req.Method = ""
    req.URL = nil
    req.Body = nil
    req.ContentLength = 0
    req.Header.Reset()
    return req
}


// 釋放請(qǐng)求對(duì)象到池
func ReleaseRequest(req *http.Request) {
    requestPool.Put(req)
}