深入解析 Golang 中的 http.RoundTripper：HTTP 客户端的引擎

type RoundTripper interface {
    RoundTrip(*Request) (*Response, error)
}

package main

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

// customTransport 包装了一个 http.RoundTripper
type customTransport struct {
	// next 是底层的 RoundTripper，通常是 http.DefaultTransport
	next http.RoundTripper
}

// RoundTrip 实现了 http.RoundTripper 接口
func (t *customTransport) RoundTrip(req *http.Request) (*http.Response, error) {
	// 在请求发送前执行的操作
	req.Header.Set("User-Agent", "My-Awesome-Go-Client/1.0")
	log.Printf("发送请求: %s %s", req.Method, req.URL)

	start := time.Now()

	// 调用底层的 RoundTripper 来实际发送请求
	// 如果 next 为 nil, 可以使用 http.DefaultTransport
    transport := t.next
    if transport == nil {
        transport = http.DefaultTransport
    }
	resp, err := transport.RoundTrip(req)

	// 在收到响应后执行的操作
	if err != nil {
		log.Printf("请求失败: %v", err)
		return nil, err
	}

	duration := time.Since(start)
	log.Printf("收到响应: %s, 耗时: %v", resp.Status, duration)

	return resp, nil
}

func main() {
	// 创建一个 http.Client 并使用我们的自定义 Transport
	client := &http.Client{
		Transport: &customTransport{},
	}

	// 使用这个 client 发送请求
	resp, err := client.Get("https://www.google.com")
	if err != nil {
		log.Fatalf("请求错误: %v", err)
	}
	defer resp.Body.Close()

	// ... 处理响应 ...
}

// 认证 RoundTripper
type authTransport struct {
    apiKey string
    next   http.RoundTripper
}

func (t *authTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    req.Header.Set("X-API-Key", t.apiKey)
    return t.next.RoundTrip(req)
}

// ... (省略 loggingTransport 的实现) ...

func main() {
    // 创建底层的 transport
    baseTransport := http.DefaultTransport

    // 链式创建 transports
    // 最外层是 logging, 内层是 auth
    logging := &loggingTransport{next: &authTransport{apiKey: "my-secret-key", next: baseTransport}}

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

    // ...
}

package main

import (
	"bytes"
	"io"
	"log"
	"math"
	"net/http"
	"time"
)

// RetryableTransport 实现了 http.RoundTripper 接口，并添加了重试逻辑
type RetryableTransport struct {
	next       http.RoundTripper // 下一个 RoundTripper，通常是 http.DefaultTransport
	maxRetries int               // 最大重试次数
	initDelay  time.Duration     // 初始延迟时间
}

// NewRetryableTransport 创建一个新的 RetryableTransport 实例
func NewRetryableTransport(next http.RoundTripper, maxRetries int, initDelay time.Duration) *RetryableTransport {
	if next == nil {
		next = http.DefaultTransport
	}
	return &RetryableTransport{
		next:       next,
		maxRetries: maxRetries,
		initDelay:  initDelay,
	}
}

// RoundTrip 是实现重试逻辑的核心
func (t *RetryableTransport) RoundTrip(req *http.Request) (*http.Response, error) {
	var (
		resp *http.Response
		err  error
		bodyBytes []byte
	)

	// 如果有请求体，我们需要提前读取并保存它，以便在重试时可以重用。
	// http.Request.GetBody 可以更优雅地处理这个问题，但为了演示，我们手动处理。
	if req.Body != nil {
		bodyBytes, err = io.ReadAll(req.Body)
		if err != nil {
			return nil, err
		}
		// 关闭原始请求体
		req.Body.Close()
	}


	for i := 0; i < t.maxRetries; i++ {
		// 如果有请求体，为每次尝试创建一个新的 io.Reader
		if len(bodyBytes) > 0 {
			req.Body = io.NopCloser(bytes.NewReader(bodyBytes))
		}

		// 发送请求
		resp, err = t.next.RoundTrip(req)

		// 检查是否应该重试
		// 1. 如果有网络错误 (err != nil)
		// 2. 如果有服务端错误 (5xx)
		if err != nil || (resp != nil && resp.StatusCode >= 500) {
			log.Printf("尝试 #%d: 请求失败 (错误: %v, 状态码: %d), 准备重试...", i+1, err, Btoi(resp))

			// 计算下一次重试的延迟（指数退避）
			delay := t.initDelay * time.Duration(math.Pow(2, float64(i)))
			log.Printf("等待 %v 后重试", delay)
			time.Sleep(delay)

			// 在重试前确保关闭上一次的响应体，防止连接泄露
			if resp != nil {
				resp.Body.Close()
			}
			continue
		}

		// 如果请求成功或遇到不可重试的错误，则跳出循环
		break
	}

	// 返回最后一次尝试的结果
	return resp, err
}

// Btoi 是一个辅助函数，用于在 resp 为 nil 时安全地获取状态码
func Btoi(resp *http.Response) int {
	if resp == nil {
		return 0
	}
	return resp.StatusCode
}

// ---- 以下为使用示例 ----

var requestCount = 0

// mockServerHandler 创建一个模拟服务器，它会先失败几次，然后成功
func mockServerHandler(w http.ResponseWriter, r *http.Request) {
	requestCount++
	log.Printf("[服务端] 收到第 %d 次请求\n", requestCount)

	// 模拟前两次请求为服务器内部错误
	if requestCount <= 2 {
		log.Println("[服务端] 模拟服务器内部错误 500")
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte("Internal Server Error"))
		return
	}

	// 第三次请求成功
	log.Println("[服务端] 响应成功 200 OK")
	w.WriteHeader(http.StatusOK)
	w.Write([]byte("Hello, world!"))
}

func main() {
	// 启动模拟服务器
	go func() {
		http.HandleFunc("/", mockServerHandler)
		log.Println("模拟服务器启动在 :8080")
		if err := http.ListenAndServe(":8080", nil); err != nil {
			log.Fatalf("无法启动服务器: %v", err)
		}
	}()

	// 等待服务器启动
	time.Sleep(1 * time.Second)


	// 创建一个使用了我们自定义重试 Transport 的 HTTP client
	client := &http.Client{
		Transport: NewRetryableTransport(nil, 4, 1*time.Second), // 重试4次，初始延迟1秒
	}

	log.Println("客户端开始发送请求...")
	resp, err := client.Get("http://localhost:8080")
	if err != nil {
		log.Fatalf("请求在所有重试后最终失败: %v", err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	log.Printf("最终成功! 状态码: %s, 响应: %s\n", resp.Status, string(body))
}