go-zero(九) RPC拦截器的使用

go zero 拦截器详解

在微服务架构中，拦截器(Interceptor)是一种强大的机制，用于在 RPC 调用的生命周期中注入自定义逻辑。go-zero可以设置多个拦截器，比如身份验证、日志记录、请求限流、性能监控等，这些都可以通过拦截器实现

一、拦截器基础概念

1. 什么是拦截器？

拦截器是 gRPC 框架提供的一种机制，允许开发者在 RPC 调用的不同阶段插入自定义逻辑。根据应用场景，拦截器分为两种类型：

• 服务端拦截器(Server Interceptor)：在服务端处理请求前后执行自定义逻辑
• 客户端拦截器(Client Interceptor)：在客户端发送请求前后执行自定义逻辑

2. 拦截器的主要作用

拦截器能够在 RPC 调用链中实现多种功能：

• 日志记录：捕获请求和响应信息，便于调试和监控
• 认证授权：验证请求者身份和权限
• 请求追踪：实现分布式链路追踪
• 性能度量：记录请求处理时间和资源使用情况
• 错误处理：统一处理和转换错误信息
• 限流熔断：控制请求流量，防止系统过载
• 请求参数校验：在服务层面验证请求参数

二、拦截器与中间件的区别与联系

在 go-zero 框架中，拦截器和中间件都是用于在请求处理流程中注入自定义逻辑的机制，但它们各自适用于不同的场景和协议层。

1. 概念与作用域

中间件 (Middleware):

• 作用域: 作用于 HTTP 请求处理流程
• 应用场景: REST API 服务
• 位置: API 网关层、HTTP 服务层
• 实现方式: 基于标准库的 http.Handler 接口

拦截器 (Interceptor):

• 作用域: 作用于 RPC 调用流程
• 应用场景: 微服务间内部通信
• 位置: RPC 服务层
• 实现方式: 基于 gRPC 的拦截器接口

2. 详细对比

三、服务端拦截器

服务端拦截器在 RPC 服务处理请求前后执行，可以用于请求验证、权限检查、日志记录等场景。

AddUnaryInterceptors 是在 gRPC 服务器初始化时调用的方法，用于将一个或多个服务端拦截器注册到 gRPC 服务器上.

1. 服务端拦截器定义

服务端拦截器必须遵循 gRPC 定义的函数签名：

func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error)

各参数含义：

• ctx: 请求上下文，包含元数据
• req: 客户端请求参数
• info: RPC 方法的相关信息，如方法名
• handler: 实际处理请求的处理器

2. 实现服务拦截器

接下来我们使用两个，拦截器作为演示

日志拦截器
记录每个 RPC 请求的详细信息，包括方法名、请求参数、处理时间等：

func LoggingInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    // 记录请求开始时间
    startTime := time.Now()
    
    // 提取请求方法名
    method := path.Base(info.FullMethod)
    
    // 记录请求信息
    logx.Infof("Request - Method: %s, Time: %s, Request: %+v", 
        method, startTime.Format(time.RFC3339), req)
    
    // 调用实际处理器
    resp, err := handler(ctx, req)
    
    // 计算处理时间
    duration := time.Since(startTime)
    
    // 记录响应信息
    if err != nil {
        logx.Errorf("Response - Method: %s, Duration: %s, Error: %v", 
            method, duration, err)
    } else {
        logx.Infof("Response - Method: %s, Duration: %s, Response: %+v", 
            method, duration, resp)
    }
    
    return resp, err
}

限流拦截器

控制服务端处理请求的速率，防止系统过载：

// 使用令牌桶算法实现限流
limiter := rate.NewLimiter(rate.Limit(1), 1) //设置低一点，方便测试 每秒1个请求，突发最多1个
   
func RateLimitInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {

    if !limiter.Allow() {
        return nil, status.Error(codes.ResourceExhausted, "请求频率过高，请稍后再试")
    }
    
    return handler(ctx, req)
}

3. 在go-zero中注册服务端拦截器

在RPC服务的main.go文件中注册拦截器：

func main() {
    flag.Parse()
    
    var c config.Config
    conf.MustLoad(*configFile, &c)
    
    ctx := svc.NewServiceContext(c)
    svr := server.NewUserServer(ctx)
    
    s := zrpc.MustNewServer(c.RpcServerConf, func(grpcServer *grpc.Server) {
        pb.RegisterUserServer(grpcServer, svr)
        
        if c.Mode == service.DevMode || c.Mode == service.TestMode {
            reflection.Register(grpcServer)
        }
    })
    
    // 注册多个服务端拦截器（按顺序执行）
    s.AddUnaryInterceptors(
        LoggingInterceptor,
        RateLimitInterceptor, 
    )
    
    defer s.Stop()
    
    fmt.Printf("Starting RPC server at %s...\n", c.ListenOn)
    s.Start()
}

4. 测试拦截器

业务逻辑就简单的使用 goctl rpc new user 生成的代码。

四、客户端拦截器

客户端拦截器在发起 RPC 调用前后执行，用于请求前的预处理和响应后的后处理。go-zero 提供了 WithUnaryClientInterceptor 选项来配置客户端拦截器。

1. 客户端拦截器定义

客户端拦截器必须遵循 gRPC 定义的函数签名：

func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error

各参数含义：

• ctx: 请求上下文
• method: 完整的 RPC 方法名
• req: 请求参数
• reply: 响应结果
• cc: gRPC 客户端连接
• invoker: 实际执行 RPC 调用的调用器
• opts: 调用选项

2.实现性能监控拦截器

记录每个 RPC 调用的耗时和状态，便于性能分析：

func MetricsInterceptor(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
    // 记录开始时间
    startTime := time.Now()
    
    // 提取方法名（去除服务前缀）
    methodName := path.Base(method)
    
    // 调用 RPC 方法
    err := invoker(ctx, method, req, reply, cc, opts...)
    
    // 计算耗时
    duration := time.Since(startTime)
    
    // 记录指标
    status := "success"
    if err != nil {
        status = "error"
    }
    
    // 这里可以集成 Prometheus 等监控系统
    logx.Infof("RPC调用 - 方法: %s, 状态: %s, 耗时: %v", methodName, status, duration)
    
    return err
}

3. 注册客户端拦截器

在 API 服务的 internal/svc/servicecontext.go 文件中注册客户端拦截器：

func NewServiceContext(c config.Config) *ServiceContext {

    // 创建指标拦截器
    metricsInterceptor := MetricsInterceptor

    // 配置 RPC 客户端，添加拦截器链
    userRpc := user.NewUser(zrpc.MustNewClient(c.UserRpcConf, 
        zrpc.WithUnaryClientInterceptor(
            metricsInterceptor,  // 先记录指标
        ),
    ))
    
    return &ServiceContext{
        Config: c,
        UserRpc: userRpc,
    }
}

这里就不演示了， 还可以自行拓展 ：重试拦截器、超时拦截器等等。

如果是使用多个拦截器，要注意调用顺序 ，指标记录>令牌注入>超时控制>重试

五、拦截器最佳实践

1. 设计原则

设计高效的拦截器应遵循以下原则：

• 单一职责: 每个拦截器只负责一项功能
• 正交性: 拦截器之间应尽量减少耦合
• 性能优先: 拦截器应高效执行，避免阻塞
• 异常安全: 拦截器不应干扰正常的请求处理流程
• 可配置性: 拦截器行为应可通过配置调整
• 可测试性: 拦截器应易于单元测试

2. 拦截器链顺序设计

拦截器的执行顺序对系统行为有显著影响，合理的顺序安排如下：

服务端拦截器顺序:

1. 恢复处理 (Recover)
2. 日志记录 (Logging)
3. 指标收集 (Metrics)
4. 认证授权 (Authentication & Authorization)
5. 限流熔断 (Rate Limiting & Circuit Breaking)
6. 参数验证 (Validation)
7. 业务处理 (Business Logic)

客户端拦截器顺序:

1. 指标收集 (Metrics)
2. 日志记录 (Logging)
3. 认证注入 (Authentication)
4. 超时控制 (Timeout)
5. 重试处理 (Retry)