在分布式系统中，Golang服务之间通过RPC完成通信是非常常见的场景，但网络抖动、下游服务过载、超时等问题都会导致RPC调用失败，如何正确处理这些异常并设计合理的重试机制，是提升服务稳定性的关键。
Golang RPC调用常见异常类型
首先我们需要明确Golang中RPC调用会出现哪些异常，才能针对性地处理：
- 网络类异常：包括连接超时、连接被拒绝、网络中断等，通常是临时性的网络问题导致
- 超时异常：调用方设置的上下文超时，或者下游服务处理时间超过预期
- 业务类异常：下游服务返回的业务错误码，比如参数校验失败、权限不足等，这类异常通常不需要重试
- 服务不可用异常：下游服务宕机、正在重启等，短期内无法恢复的情况
基础异常处理实现
我们先看一个最基础的Golang RPC调用异常处理示例，这里以标准库的net/rpc为例：
package main
import (
"fmt"
"log"
"net/rpc"
"time"
)
// 定义RPC请求和响应结构
type Args struct {
A, B int
}
type Reply struct {
Result int
}
func main() {
// 建立RPC连接
client, err := rpc.Dial("tcp", "127.0.0.1:1234")
if err != nil {
log.Printf("建立RPC连接失败: %v", err)
return
}
defer client.Close()
args := &Args{A: 1, B: 2}
reply := &Reply{}
// 设置调用超时
callTimeout := time.Second * 3
done := make(chan error, 1)
go func() {
// 调用RPC方法
err := client.Call("MathService.Add", args, reply)
done <- err
}()
select {
case err := <-done:
if err != nil {
// 处理RPC调用异常
log.Printf("RPC调用失败: %v", err)
return
}
fmt.Printf("RPC调用成功，结果: %dn", reply.Result)
case <-time.After(callTimeout):
log.Printf("RPC调用超时")
return
}
}
重试机制设计要点
不是所有异常都适合重试，设计重试机制时需要遵循几个原则：
- 只对临时性异常重试，比如网络抖动、超时，业务错误、服务永久不可用的情况不重试
- 设置最大重试次数，避免无限重试导致资源耗尽
- 采用指数退避策略，重试间隔逐渐增加，减少对下游服务的压力
- 支持重试条件自定义，方便不同场景下的差异化配置
完整重试实践示例
下面是一个包含异常处理和重试机制的完整Golang RPC调用封装示例：
package main
import (
"fmt"
"log"
"math"
"net/rpc"
"time"
)
type Args struct {
A, B int
}
type Reply struct {
Result int
}
// 定义重试配置
type RetryConfig struct {
MaxRetry int // 最大重试次数
BaseDelay time.Duration // 基础退避时间
MaxDelay time.Duration // 最大退避时间
RetryCheck func(err error) bool // 判断是否需要重试的函数
}
// 默认重试条件：网络错误或超时错误重试
func defaultRetryCheck(err error) bool {
if err == nil {
return false
}
// 这里可以根据实际错误类型判断，比如包含timeout、connection refused等关键字
errMsg := err.Error()
return errMsg == "connection refused" || errMsg == "i/o timeout"
}
// 封装带重试的RPC调用
func CallRPCWithRetry(client *rpc.Client, serviceMethod string, args interface{}, reply interface{}, config RetryConfig) error {
var lastErr error
for i := 0; i <= config.MaxRetry; i++ {
if i > 0 {
// 计算退避时间：baseDelay * 2^(i-1)，不超过maxDelay
delay := time.Duration(math.Min(float64(config.BaseDelay*time.Duration(math.Pow(2, float64(i-1)))), float64(config.MaxDelay)))
log.Printf("第%d次重试，等待%d毫秒", i, delay.Milliseconds())
time.Sleep(delay)
}
// 执行RPC调用
done := make(chan error, 1)
go func() {
done <- client.Call(serviceMethod, args, reply)
}()
select {
case err := <-done:
if err == nil {
return nil
}
lastErr = err
// 判断是否需要重试
if !config.RetryCheck(err) {
log.Printf("不需要重试的错误: %v", err)
return err
}
log.Printf("第%d次调用失败: %v", i+1, err)
case <-time.After(time.Second * 3):
lastErr = fmt.Errorf("调用超时")
log.Printf("第%d次调用超时", i+1)
// 超时错误默认重试
if !config.RetryCheck(lastErr) {
return lastErr
}
}
}
return fmt.Errorf("达到最大重试次数%d，最后错误: %v", config.MaxRetry, lastErr)
}
func main() {
// 建立连接，这里模拟连接失败场景
client, err := rpc.Dial("tcp", "127.0.0.1:1234")
if err != nil {
log.Printf("初始连接失败: %v，尝试重试连接", err)
// 连接也可以加入重试逻辑，这里简化为直接返回
return
}
defer client.Close()
// 配置重试参数
retryConfig := RetryConfig{
MaxRetry: 3,
BaseDelay: time.Millisecond * 100,
MaxDelay: time.Second * 2,
RetryCheck: defaultRetryCheck,
}
args := &Args{A: 10, B: 20}
reply := &Reply{}
err = CallRPCWithRetry(client, "MathService.Add", args, reply, retryConfig)
if err != nil {
log.Printf("RPC调用最终失败: %v", err)
return
}
fmt.Printf("RPC调用成功，结果: %dn", reply.Result)
}
注意事项
在实际使用中还需要注意几个问题：
- 如果RPC调用是写操作，需要确认下游服务是否支持幂等，避免重试导致重复写入数据
- 重试机制会增加调用耗时，需要根据业务场景平衡重试次数和响应时间要求
- 可以结合监控上报重试次数、失败原因等指标，方便后续排查问题
- 如果使用的是gRPC等其他RPC框架，异常处理和重试的思路是通用的，只是具体的错误判断和调用方式需要调整