深入解析如何基于go-retry构建灵活安全和高效的重试逻辑

go get github.com/sethvargo/go-retry@latest

package main

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

	retry "github.com/sethvargo/go-retry"
)

// 模拟不稳定的 API 调用
func callUnstableAPI() error {
	resp, err := http.Get("https://api.example.com/unstable")
	if err != nil {
		fmt.Println("API 调用失败:", err)
		return err // 网络错误，可重试
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		fmt.Printf("API 返回非 200 状态码: %d\n", resp.StatusCode)
		return fmt.Errorf("status code: %d", resp.StatusCode) // 非 200 可重试
	}

	fmt.Println("API 调用成功!")
	return nil
}

func main() {
	// 1. 创建上下文（支持超时/取消）
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	// 2. 定义重试策略：固定间隔 2 秒，最多重试 5 次
	// ConstantBackoff(间隔) + LimitMaxRetries(最大次数)
	strategy := retry.WithMaxRetries(5, retry.ConstantBackoff(2*time.Second))

	// 3. 执行重试逻辑
	err := retry.Do(ctx, strategy, func(ctx context.Context) error {
		err := callUnstableAPI()
		if err != nil {
			// 标记错误为“可重试”，触发下一次重试
			return retry.RetryableError(err)
		}
		return nil // 成功则终止重试
	})

	// 4. 处理最终结果
	if err != nil {
		fmt.Printf("所有重试失败: %v\n", err)
		return
	}
	fmt.Println("重试流程正常结束")
}

// 每次重试间隔 1 秒，最多重试 3 次
strategy := retry.WithMaxRetries(3, retry.ConstantBackoff(1*time.Second))

// 初始间隔 1 秒，最大间隔 10 秒，最多重试 5 次
// 间隔：1s → 2s → 4s → 8s → 10s（后续保持 10s）
strategy := retry.WithMaxRetries(5, retry.ExponentialBackoff(1*time.Second, 10*time.Second))

// 指数退避 + 抖动，初始 1s，最大 10s，最多 5 次
strategy := retry.WithMaxRetries(5, retry.Jitter(retry.ExponentialBackoff(1*time.Second, 10*time.Second), 0.5))
// 第二个参数是抖动因子（0-1），因子越大，随机波动越明显

// 初始间隔 1s，每次增加 1s，最大间隔 5s，最多重试 4 次
strategy := retry.WithMaxRetries(4, retry.LinearBackoff(1*time.Second, 1*time.Second, 5*time.Second))

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	// 仅重试“网络错误”和“5xx 状态码错误”
	strategy := retry.WithMaxRetries(5, retry.ConstantBackoff(2*time.Second))

	err := retry.Do(ctx, strategy, func(ctx context.Context) error {
		err := callUnstableAPI()
		if err != nil {
			// 自定义过滤逻辑：判断错误类型是否可重试
			if isRetryableError(err) {
				return retry.RetryableError(err)
			}
			return err // 不可重试错误，直接终止
		}
		return nil
	})

	if err != nil {
		fmt.Printf("最终失败: %v\n", err)
	}
}

// 定义可重试错误的判断逻辑
func isRetryableError(err error) bool {
	// 网络错误（如连接超时、拒绝连接）
	if _, ok := err.(*http.Error); ok {
		return true
	}
	// 5xx 状态码错误
	if err.Error()[:3] == "500" || err.Error()[:3] == "503" {
		return true
	}
	// 其他错误（如 400、404）不可重试
	return false
}

func main() {
	// 1. 设置整体超时 15 秒
	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	// 2. 启动一个 goroutine，模拟用户手动取消（5 秒后）
	go func() {
		time.Sleep(5 * time.Second)
		fmt.Println("用户手动取消重试")
		cancel()
	}()

	// 3. 重试策略：指数退避，最多 10 次（但会被超时/取消中断）
	strategy := retry.WithMaxRetries(10, retry.ExponentialBackoff(1*time.Second, 5*time.Second))

	err := retry.Do(ctx, strategy, func(ctx context.Context) error {
		// 检查上下文是否已取消/超时
		select {
		case <-ctx.Done():
			return ctx.Err() // 传递取消信号
		default:
		}

		return retry.RetryableError(callUnstableAPI())
	})

	if err != nil {
		fmt.Printf("重试终止: %v\n", err) // 可能是超时或取消错误
	}
}

// 自定义策略：前 3 次间隔 1 秒，之后间隔 3 秒
type CustomStrategy struct {
	maxRetries int
}

func (s *CustomStrategy) NextRetry(ctx context.Context, attempt int) (time.Duration, error) {
	// attempt 是已重试次数（从 0 开始）
	if attempt >= s.maxRetries {
		return 0, retry.ErrMaxRetriesExceeded // 达到最大次数，终止
	}

	// 前 3 次间隔 1s，之后 3s
	if attempt < 3 {
		return 1 * time.Second, nil
	}
	return 3 * time.Second, nil
}

// 使用自定义策略
func main() {
	ctx := context.Background()
	strategy := &CustomStrategy{maxRetries: 5}

	err := retry.Do(ctx, strategy, func(ctx context.Context) error {
		return retry.RetryableError(callUnstableAPI())
	})
}

func main() {
	ctx := context.Background()

	// 添加回调函数，监控每次重试
	strategy := retry.WithCallback(
		retry.WithMaxRetries(5, retry.ConstantBackoff(2*time.Second)),
		func(ctx context.Context, attempt int, err error, next time.Duration) {
			fmt.Printf("第 %d 次重试失败: %v，下次重试间隔 %v\n", attempt+1, err, next)
			// 此处可添加指标上报（如 Prometheus 计数器）
			// retryTotal.WithLabelValues("api").Inc()
		},
	)

	err := retry.Do(ctx, strategy, func(ctx context.Context) error {
		return retry.RetryableError(callUnstableAPI())
	})
}