GolangRPC调用错误处理与重试策略

error

fmt.Errorf

%w

errors.Is

errors.As

context.Context

error

errors.New("something failed")

fmt.Errorf("failed: %w", err)

package common

import (
    "fmt"
)

// RPCError 定义了通用的RPC错误结构
type RPCError struct {
    Code    int    // 错误码，用于标识特定类型的错误
    Message string // 错误消息，更具体的描述
    // 内部错误，如果需要包装底层错误，可以加上这个字段
    // 这里为了简化，暂时省略，但实际项目中可以考虑
    // Inner error
}

// Error 实现 error 接口
func (e *RPCError) Error() string {
    return fmt.Sprintf("RPC Error %d: %s", e.Code, e.Message)
}

// 定义一些常用的错误常量
var (
    ErrNotFound      = &RPCError{Code: 404, Message: "资源未找到"}
    ErrInvalidArgument = &RPCError{Code: 400, Message: "无效的请求参数"}
    ErrInternal      = &RPCError{Code: 500, Message: "服务器内部错误"}
)

// NewRPCError 方便创建自定义RPC错误
func NewRPCError(code int, msg string) *RPCError {
    return &RPCError{Code: code, Message: msg}
}

// 服务端示例
func (s *MyService) GetItem(ctx context.Context, req *ItemRequest) (*ItemResponse, error) {
    if req.Id == "" {
        return nil, common.ErrInvalidArgument // 直接返回预定义的错误
    }
    item, err := s.store.Get(req.Id)
    if err != nil {
        if errors.Is(err, storage.ErrItemNotFound) { // 假设storage层有自己的错误
            return nil, common.ErrNotFound
        }
        // 包装其他底层错误，但返回自定义RPCError类型
        return nil, common.NewRPCError(500, fmt.Sprintf("获取物品失败: %s", err.Error()))
    }
    return &ItemResponse{Item: item}, nil
}

errors.Is

errors.As

// 客户端示例
resp, err := client.GetItem(context.Background(), &ItemRequest{Id: "123"})
if err != nil {
    var rpcErr *common.RPCError
    if errors.As(err, &rpcErr) { // 尝试将错误转换为我们的RPCError类型
        switch rpcErr.Code {
        case common.ErrNotFound.Code:
            fmt.Println("客户端：物品未找到，可能需要引导用户创建。")
        case common.ErrInvalidArgument.Code:
            fmt.Println("客户端：请求参数有问题，检查输入。")
        default:
            fmt.Printf("客户端：收到未知RPC错误: %s\n", rpcErr.Error())
        }
    } else {
        fmt.Printf("客户端：收到非RPC错误: %s\n", err.Error())
    }
    return
}
fmt.Printf("客户端：获取到物品: %v\n", resp.Item)

package main

import (
    "context"
    "errors"
    "fmt"
    "math/rand"
    "time"
)

// SimulateRPCCall 模拟一个可能失败的RPC调用
func SimulateRPCCall(attempt int) error {
    // 假设前3次调用会失败，第4次成功
    if attempt < 3 {
        return errors.New("模拟RPC调用失败: 服务暂时不可用")
    }
    fmt.Printf("第 %d 次尝试：RPC调用成功！\n", attempt+1)
    return nil
}

func main() {
    const (
        maxRetries    = 5
        baseDelay     = 100 * time.Millisecond
        maxDelay      = 5 * time.Second
    )

    rand.Seed(time.Now().UnixNano()) // 初始化随机数种子

    for i := 0; i < maxRetries; i++ {
        err := SimulateRPCCall(i)
        if err == nil {
            fmt.Println("RPC调用最终成功。")
            return
        }

        fmt.Printf("第 %d 次尝试失败: %s\n", i+1, err.Error())

        // 如果是最后一次重试，直接退出
        if i == maxRetries-1 {
            fmt.Println("达到最大重试次数，RPC调用最终失败。")
            return
        }

        // 计算指数退避延迟
        currentDelay := baseDelay * time.Duration(1<<uint(i)) // 2^i
        if currentDelay > maxDelay {
            currentDelay = maxDelay
        }

        // 添加抖动 (Full Jitter: 随机选择 0 到 currentDelay 之间的一个值)
        jitter := time.Duration(rand.Int63n(int64(currentDelay)))
        sleepTime := jitter
        // 也可以使用 Equal Jitter: currentDelay/2 + rand(0, currentDelay/2)
        // sleepTime := currentDelay/2 + time.Duration(rand.Int63n(int64(currentDelay/2)))

        fmt.Printf("等待 %v 后进行第 %d 次重试...\n", sleepTime, i+2)
        time.Sleep(sleepTime)
    }
}

context

sony/gobreaker

package main

import (
    "context"
    "errors"
    "fmt"
    "time"

    "github.com/sony/gobreaker"
)

// SimulateExternalService 模拟一个外部RPC服务，可能失败
var failureCount = 0

func SimulateExternalService(ctx context.Context) (string, error) {
    failureCount++
    if failureCount < 3 { // 模拟前2次失败
        fmt.Printf("服务调用失败 (第 %d 次)\n", failureCount)
        return "", errors.New("模拟服务内部错误")
    }
    if failureCount == 3 { // 模拟第3次成功
        fmt.Println("服务调用成功！")
        return "Data from Service", nil
    }
    // 之后每次都成功
    fmt.Println("服务调用成功！")
    return "Data from Service", nil
}

func main() {
    // 配置熔断器
    // MaxRequests: 半开状态下允许通过的请求数
    // Interval: 统计周期
    // Timeout: 打开状态持续多久后进入半开
    // ReadyToTrip: 判断是否需要熔断的函数 (默认是失败率超过阈值)
    // OnStateChange: 状态变化时的回调
    settings := gobreaker.Settings{
        Name:        "MyRPCService",
        MaxRequests: 1, // 半开状态下只允许1个请求通过
        Interval:    10 * time.Second, // 统计周期，超过这个时间会重置计数
        Timeout:     5 * time.Second,  // 打开状态持续5秒后进入半开
        ReadyToTrip: func(counts gobreaker.Counts) bool {
            // 默认实现：当请求总数大于等于3，且失败率超过60%时，熔断
            return counts.Requests >= 3 && float64(counts.TotalFailures)/float64(counts.Requests) >= 0.6
        },
        OnStateChange: func(name string, from gobreaker.State, to gobreaker.State) {
            fmt