怎样处理Golang中的临时性错误 实现自动恢复与降级逻辑

func isTransient(err error) bool {
    if netErr, ok := err.(net.Error); ok {
        return netErr.Temporary() || netErr.Timeout()
    }
    if err == io.ErrUnexpectedEOF || err == context.DeadlineExceeded {
        return true
    }
    // 可添加更多业务相关临时错误判断
    return strings.Contains(err.Error(), "timeout") ||
           strings.Contains(err.Error(), "connection reset")
}

func retry(attempts int, delay time.Duration, fn func() error) error {
    for i := 0; i < attempts; i++ {
        err := fn()
        if err == nil {
            return nil
        }

        if !isTransient(err) {
            return err // 非临时错误，立即返回
        }

        if i < attempts-1 {
            jitter := time.Duration(rand.Int63n(int64(delay)))
            sleep := delay + jitter
            time.Sleep(sleep)
            delay *= 2 // 指数退避
        }
    }
    return fmt.Errorf("retry failed after %d attempts: %w", attempts, fn())
}

github.com/cenkalti/backoff/v4

import "github.com/cenkalti/backoff/v4"

err := backoff.Retry(func() error {
    return callExternalAPI()
}, backoff.WithMaxRetries(backoff.NewExponentialBackOff(), 5))

if err != nil {
    // 重试失败，进入降级
}

context

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

operation := func() error {
    reqCtx, _ := context.WithTimeout(ctx, 2*time.Second)
    return doHTTPRequest(reqCtx)
}

err := backoff.Retry(operation, backoff.WithContext(backoff.WithMaxRetries(backoff.NewExponentialBackOff(), 3), ctx))

func getDataWithFallback() (Data, error) {
    var result Data
    err := retry(3, 100*time.Millisecond, func() error {
        data, err := fetchFromRemote()
        if err != nil {
            return err
        }
        result = data
        return nil
    })

    if err != nil {
        log.Printf("Remote failed, falling back: %v", err)
        result = getFallbackData() // 返回默认或缓存数据
    }

    return result, nil
}

github.com/sony/gobreaker

var cb *gobreaker.CircuitBreaker

func init() {
    cb = gobreaker.NewCircuitBreaker(gobreaker.Settings{
        Name:        "remote-api",
        MaxRequests: 3,
        Timeout:     10 * time.Second,
        ReadyToTrip: func(counts gobreaker.Counts) bool {
            return counts.ConsecutiveFailures > 3
        },
    })
}

// 使用熔断器包装调用
result, err := cb.Execute(func() (interface{}, error) {
    data, err := callExternalAPI()
    return data, err
})

log.Printf("retry attempt %d due to: %v", attempt, err)