Golang重试机制实现：retry-go库使用指南

在分布式系统和网络编程中，重试机制是处理瞬时故障的常见策略。retry-go是一个简单易用的Golang重试库，下面我将详细介绍它的使用方法。

retry-go基本使用

安装

go get github.com/avast/retry-go

基本示例

package main

import (
	"fmt"
	"time"
	
	"github.com/avast/retry-go"
)

func main() {
	var result string
	err := retry.Do(
		func() error {
			var err error
			result, err = someOperation()
			return err
		},
		retry.Attempts(3),
		retry.Delay(100*time.Millisecond),
		retry.OnRetry(func(n uint, err error) {
			fmt.Printf("Retry #%d: %s\n", n, err)
		}),
	)
	
	if err != nil {
		fmt.Println("Operation failed:", err)
		return
	}
	
	fmt.Println("Success:", result)
}

func someOperation() (string, error) {
	// 模拟有时会失败的操作
	if time.Now().UnixNano()%2 == 0 {
		return "success", nil
	}
	return "", fmt.Errorf("random error")
}

核心配置选项

retry-go提供了多种配置选项：

err := retry.Do(
	func() error {
		// 你的业务逻辑
	},
	retry.Attempts(5),                  // 最大重试次数
	retry.Delay(1*time.Second),          // 基础延迟
	retry.MaxDelay(5*time.Second),       // 最大延迟
	retry.DelayType(retry.BackOffDelay), // 退避策略
	retry.OnRetry(func(n uint, err error) {
		// 每次重试时的回调
	}),
	retry.RetryIf(func(err error) bool {
		// 决定哪些错误需要重试
		return shouldRetry(err)
	}),
	retry.LastErrorOnly(true),           // 只返回最后一次错误
)

高级特性

自定义重试条件

err := retry.Do(
	func() error {
		return someHTTPRequest()
	},
	retry.RetryIf(func(err error) bool {
		// 只对网络错误和5xx状态码重试
		if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
			return true
		}
		if httpErr, ok := err.(*HTTPError); ok && httpErr.Code >= 500 {
			return true
		}
		return false
	}),
)

指数退避策略

err := retry.Do(
	func() error {
		return someOperation()
	},
	retry.DelayType(retry.BackOffDelay),
	retry.MaxDelay(10*time.Second),
	retry.MaxJitter(1*time.Second),
)

上下文支持

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

err := retry.Do(
	func() error {
		return someOperationWithContext(ctx)
	},
	retry.Context(ctx),
)

实际应用示例

HTTP请求重试

func GetWithRetry(url string) ([]byte, error) {
	var body []byte
	
	err := retry.Do(
		func() error {
			resp, err := http.Get(url)
			if err != nil {
				return err
			}
			defer resp.Body.Close()
			
			if resp.StatusCode >= 500 {
				return fmt.Errorf("server error: %d", resp.StatusCode)
			}
			
			body, err = io.ReadAll(resp.Body)
			return err
		},
		retry.Attempts(3),
		retry.Delay(1*time.Second),
		retry.RetryIf(func(err error) bool {
			return err != nil
		}),
	)
	
	return body, err
}

数据库操作重试

func QueryWithRetry(db *sql.DB, query string, args ...interface{}) (*sql.Rows, error) {
	var rows *sql.Rows
	var err error
	
	err = retry.Do(
		func() error {
			rows, err = db.Query(query, args...)
			return err
		},
		retry.Attempts(5),
		retry.Delay(500*time.Millisecond),
		retry.RetryIf(func(err error) bool {
			// 只对特定数据库错误重试
			return isRetryableDBError(err)
		}),
	)
	
	return rows, err
}

最佳实践

1. 合理设置重试次数：通常3-5次足够，过多重试可能导致雪崩效应
2. 使用退避策略：避免立即重试导致服务端压力过大
3. 区分可重试错误：不是所有错误都适合重试
4. 添加日志记录：通过OnRetry回调记录重试情况
5. 考虑上下文超时：避免长时间阻塞

retry-go通过简洁的API和灵活的配置选项，为Golang开发者提供了强大的重试机制实现，能够有效处理分布式系统中的瞬时故障问题。