Golang中RPC调用错误的常见类型
在Golang的RPC调用场景中，错误主要分为三类。第一类是网络传输类错误，比如连接超时、服务端不可达、网络中断等，这类错误通常由底层网络层抛出。第二类是RPC框架层面的错误，比如序列化失败、协议不匹配、请求格式错误等。第三类是业务层面的错误，也就是服务端处理请求时返回的业务逻辑异常，比如参数校验失败、权限不足、资源不存在等。
错误类型区分的重要性
不同类型的RPC错误需要不同的处理策略，如果不做区分统一处理，可能会导致重试逻辑误触发、错误日志无法精准定位问题、业务异常被错误忽略等情况。比如网络超时错误可以发起重试，但是业务层面的参数错误重试是没有意义的，反而会加重服务负担。
标准RPC错误处理流程
基础错误处理示例
首先来看一个不使用额外封装的基础RPC调用错误处理示例，这里以Golang标准库的net/rpc为例：
package main
import (
"fmt"
"log"
"net/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: 10, B: 5}
var reply Reply
// 发起RPC调用
err = client.Call("MathService.Add", args, &reply)
if err != nil {
// 处理调用过程的错误
log.Printf("RPC调用失败: %v", err)
return
}
fmt.Printf("调用结果: %dn", reply.Result)
}
错误类型判断
上面的示例只能捕获到错误，无法区分错误类型，我们可以通过自定义错误类型来区分不同的错误场景：
package main
import (
"errors"
"fmt"
"log"
"net/rpc"
)
// 定义自定义错误类型
type RPCError struct {
Code int
Message string
}
func (e *RPCError) Error() string {
return fmt.Sprintf("RPC错误 code:%d message:%s", e.Code, e.Message)
}
// 预定义错误常量
var (
ErrNetworkTimeout = &RPCError{Code: 1001, Message: "网络超时"}
ErrServerUnreachable = &RPCError{Code: 1002, Message: "服务端不可达"}
ErrBusinessParamInvalid = &RPCError{Code: 2001, Message: "参数无效"}
)
type Args struct {
A, B int
}
type Reply struct {
Result int
}
func main() {
client, err := rpc.Dial("tcp", "127.0.0.1:1234")
if err != nil {
// 判断是否为网络相关错误
var rpcErr *RPCError
if errors.As(err, &rpcErr) {
if rpcErr.Code == 1001 {
// 超时错误可以重试
log.Println("发生超时错误，准备重试")
} else if rpcErr.Code == 1002 {
log.Println("服务端不可达，触发降级逻辑")
}
} else {
log.Printf("未知连接错误: %v", err)
}
return
}
defer client.Close()
args := &Args{A: 10, B: 5}
var reply Reply
err = client.Call("MathService.Add", args, &reply)
if err != nil {
var rpcErr *RPCError
if errors.As(err, &rpcErr) {
if rpcErr.Code >= 2000 && rpcErr.Code < 3000 {
// 业务错误，记录日志后返回给上层处理
log.Printf("业务错误: %s", rpcErr.Message)
}
} else {
log.Printf("未知调用错误: %v", err)
}
return
}
fmt.Printf("调用结果: %dn", reply.Result)
}
可复用的RPC错误封装方案
在实际项目中，我们可以封装一个统一的RPC错误处理模块，方便所有RPC调用场景复用：
package rpcutil
import (
"errors"
"fmt"
"time"
)
// 错误码定义
const (
// 网络层错误码 1xxx
CodeNetworkTimeout = 1001
CodeNetworkRefused = 1002
CodeNetworkReset = 1003
// 框架层错误码 2xxx
CodeSerializeFail = 2001
CodeDeserializeFail = 2002
CodeMethodNotFound = 2003
// 业务层错误码 3xxx
CodeParamInvalid = 3001
CodePermissionDenied = 3002
CodeResourceNotFound = 3003
)
// RPCError RPC自定义错误结构
type RPCError struct {
Code int
Message string
Err error // 原始错误
}
func (e *RPCError) Error() string {
if e.Err != nil {
return fmt.Sprintf("RPC错误 code:%d message:%s 原始错误:%v", e.Code, e.Message, e.Err)
}
return fmt.Sprintf("RPC错误 code:%d message:%s", e.Code, e.Message)
}
// 实现Unwrap方法，支持errors.As和errors.Is判断
func (e *RPCError) Unwrap() error {
return e.Err
}
// NewRPCError 创建RPC错误
func NewRPCError(code int, message string, err error) *RPCError {
return &RPCError{
Code: code,
Message: message,
Err: err,
}
}
// HandleRPCErr 统一处理RPC错误，返回是否需要重试、错误类型
func HandleRPCErr(err error) (needRetry bool, rpcErr *RPCError) {
if err == nil {
return false, nil
}
// 尝试将错误转换为RPCError
if errors.As(err, &rpcErr) {
// 网络层错误和框架层部分错误可以重试
if rpcErr.Code >= 1000 && rpcErr.Code < 2000 {
return true, rpcErr
}
return false, rpcErr
}
// 无法转换的未知错误，默认不重试
return false, NewRPCError(9999, "未知RPC错误", err)
}
// RetryCall 带重试的RPC调用
func RetryCall(callFunc func() error, maxRetry int, retryInterval time.Duration) error {
var lastErr error
for i := 0; i <= maxRetry; i++ {
err := callFunc()
if err == nil {
return nil
}
needRetry, _ := HandleRPCErr(err)
if !needRetry {
return err
}
lastErr = err
if i < maxRetry {
time.Sleep(retryInterval)
}
}
return fmt.Errorf("RPC调用重试%d次后仍然失败: %w", maxRetry, lastErr)
}
封装方案的使用示例
使用上面封装的模块处理RPC调用错误：
package main
import (
"fmt"
"log"
"time"
"your_project/rpcutil"
"net/rpc"
)
type Args struct {
A, B int
}
type Reply struct {
Result int
}
func main() {
var reply Reply
// 使用带重试的调用方式
err := rpcutil.RetryCall(func() error {
client, err := rpc.Dial("tcp", "127.0.0.1:1234")
if err != nil {
return rpcutil.NewRPCError(rpcutil.CodeNetworkRefused, "连接服务端失败", err)
}
defer client.Close()
args := &Args{A: 10, B: 5}
err = client.Call("MathService.Add", args, &reply)
if err != nil {
return rpcutil.NewRPCError(rpcutil.CodeMethodNotFound, "调用方法失败", err)
}
return nil
}, 3, time.Second*2)
if err != nil {
needRetry, rpcErr := rpcutil.HandleRPCErr(err)
if needRetry {
log.Println("错误可重试但已达最大重试次数")
}
if rpcErr != nil {
log.Printf("RPC错误码: %d, 错误信息: %s", rpcErr.Code, rpcErr.Message)
}
return
}
fmt.Printf("调用结果: %dn", reply.Result)
}
常见错误处理陷阱
- 忽略defer关闭RPC客户端连接，导致连接泄漏，长时间运行后耗尽系统资源
- 没有区分错误类型就统一发起重试，导致业务错误也被重试，浪费资源
- 直接在错误日志中打印敏感信息，比如请求参数包含用户隐私数据
- 没有对RPC调用的超时时间做设置，导致调用长时间阻塞，影响程序响应
建议在发起RPC调用前，统一设置调用的超时时间，避免无意义的长时间等待。如果是使用第三方RPC框架，需要查看框架提供的超时配置方式，合理设置连接超时和调用超时参数。
总结
在Golang中处理RPC调用错误，核心是要先明确错误的类型，再针对性地制定处理策略。通过自定义错误类型、封装统一的错误处理模块，可以让错误处理逻辑更清晰、更复用，减少重复代码。同时要注意避免常见的处理陷阱，合理设置超时和重试逻辑，才能构建出稳定可靠的分布式服务。