一文搞懂gRPC自定义拦截器

海风极客2024-03-12 9:08

在Go语言中，使用gRPC时，拦截器（Interceptor）是一个强大的工具，允许你在RPC调用的生命周期中的关键点插入自定义逻辑。通过拦截器，你可以实现各种功能，如身份验证、授权、日志记录、监控和指标收集等。

gRPC拦截器拦截器的基本概念

拦截器是一种装饰器模式，它可以附加到 gRPC 的服务端或客户端上，并按照定义的顺序执行一系列操作。拦截器可以是一元的（Unary）或流的（Stream），分别对应于单个请求-响应调用和多个消息的双向流。

在gRPC中，拦截器是链式的，可以有一个或多个。当一个RPC调用发生时，拦截器会按照定义的顺序依次执行。每个拦截器都可以决定是继续调用链中的下一个拦截器，还是直接返回错误或响应。

自定义拦截器流程

定义拦截器函数

在Go中，你可以定义一个函数作为拦截器。这个函数需要满足特定的签名要求，对于服务器端拦截器，它应该实现grpc.UnaryServerInterceptor或grpc.StreamServerInterceptor接口；对于客户端拦截器，它应该实现grpc.UnaryClientInterceptor或grpc.StreamClientInterceptor接口。

例如，创建一个简单的服务器端一元拦截器：

go 复制代码 
import (
    "context"
    "google.golang.org/grpc"
)
​
func myUnaryServerInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
    // 在调用处理程序之前执行的逻辑
​
    // 调用下一个拦截器或最终的处理程序
    resp, err = handler(ctx, req)
​
    // 在调用处理程序之后执行的逻辑
​
    return resp, err
}

注册拦截器

创建拦截器后，你需要在构建gRPC服务器或客户端时将其注册。

对于服务器：

go 复制代码 
import "google.golang.org/grpc"
​
func main() {
    // 创建gRPC服务器实例
    s := grpc.NewServer(
        grpc.UnaryInterceptor(myUnaryServerInterceptor), // 注册一元拦截器
        // grpc.StreamInterceptor(myStreamServerInterceptor), // 注册流拦截器（如果需要）
    )
​
    // 注册服务
    // ...
​
    // 启动服务器
    // ...
}

对于客户端：

go 复制代码 
import (
    "google.golang.org/grpc"
    "yourmodule/yourclient"
)
​
func main() {
    // 创建gRPC连接
    conn, err := grpc.Dial(
        "localhost:50051",
        grpc.WithInsecure(),
        grpc.WithUnaryInterceptor(myUnaryClientInterceptor), // 注册一元拦截器
        // grpc.WithStreamInterceptor(myStreamClientInterceptor), // 注册流拦截器（如果需要）
    )
    if err != nil {
        // 处理错误
    }
    defer conn.Close()
​
    // 创建客户端实例并使用连接
    client := yourclient.NewYourServiceClient(conn)
​
    // 发起RPC调用
    // ...
}

实现gRPC自定义拦截器

以下代码参考：grpc-go

服务端：

go 复制代码 
package main
​
import (
   "context"
   "fmt"
   "io"
   "log"
   "net"
   "time"
​
   "google.golang.org/grpc"
   pb "google.golang.org/grpc/examples/features/proto/echo"
)
​
type server struct {
   pb.UnimplementedEchoServer
}
​
func (s *server) UnaryEcho(ctx context.Context, in *pb.EchoRequest) (*pb.EchoResponse, error) {
   fmt.Printf("request message : %q\n", in.Message)
   return &pb.EchoResponse{Message: in.Message}, nil
}
​
func myUnaryInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
   m, err := handler(ctx, req)
   if err != nil {
      fmt.Printf("error: %v", err)
      return nil, err
   }
   return m, err
}
​
type wrappedStream struct {
   grpc.ServerStream
}
​
func (w *wrappedStream) RecvMsg(m any) error {
   fmt.Printf("Receive a message (Type: %T) at %s \n", m, time.Now().Format(time.RFC3339))
   return w.ServerStream.RecvMsg(m)
}
​
func (w *wrappedStream) SendMsg(m any) error {
   fmt.Printf("Send a message (Type: %T) at %v \n", m, time.Now().Format(time.RFC3339))
   return w.ServerStream.SendMsg(m)
}
​
func myStreamInterceptor(srv any, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
   if err := handler(srv, &wrappedStream{ss}); err != nil {
      fmt.Printf("RPC failed with error: %v", err)
      return err
   }
   return nil
}
​
func (s *server) BidirectionalStreamingEcho(stream pb.Echo_BidirectionalStreamingEchoServer) error {
   for {
      in, err := stream.Recv()
      if err != nil {
         if err == io.EOF {
            return nil
         }
         fmt.Printf("server: error receiving from stream: %v\n", err)
         return err
      }
      fmt.Printf("bidi echoing message %q\n", in.Message)
      _ = stream.Send(&pb.EchoResponse{Message: in.Message})
   }
}
​
func main() {
   lis, err := net.Listen("tcp", "127.0.0.1:8990")
   if err != nil {
      log.Fatalf("failed to listen: %v", err)
   }
​
   s := grpc.NewServer(grpc.UnaryInterceptor(myUnaryInterceptor),
      grpc.StreamInterceptor(myStreamInterceptor))
​
   pb.RegisterEchoServer(s, &server{})
​
   if err := s.Serve(lis); err != nil {
      log.Fatalf("failed to serve: %v", err)
   }
}

客户端：

go 复制代码 
package main
​
import (
   "context"
   "flag"
   "fmt"
   "io"
   "log"
   "time"
​
   "google.golang.org/grpc"
   ecpb "google.golang.org/grpc/examples/features/proto/echo"
)
​
func unaryInterceptor(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
   start := time.Now()
   err := invoker(ctx, method, req, reply, cc, opts...)
   end := time.Now()
   fmt.Printf("RPC: %s, start time: %s, end time: %s, err: %v \n", method, start.Format("Basic"), end.Format(time.RFC3339), err)
   return err
}
​
​
type wrappedStream struct {
   grpc.ClientStream
}
​
func (w *wrappedStream) RecvMsg(m any) error {
   fmt.Printf("Receive a message (Type: %T) at %v", m, time.Now().Format(time.RFC3339))
   return w.ClientStream.RecvMsg(m)
}
​
func (w *wrappedStream) SendMsg(m any) error {
   fmt.Printf("Send a message (Type: %T) at %v", m, time.Now().Format(time.RFC3339))
   return w.ClientStream.SendMsg(m)
}
​
func newWrappedStream(s grpc.ClientStream) grpc.ClientStream {
   return &wrappedStream{s}
}
​
// streamInterceptor is an example stream interceptor.
func streamInterceptor(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) {
   s, err := streamer(ctx, desc, cc, method, opts...)
   if err != nil {
      return nil, err
   }
   return newWrappedStream(s), nil
}
​
func callUnaryEcho(client ecpb.EchoClient, message string) {
   ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
   defer cancel()
   resp, err := client.UnaryEcho(ctx, &ecpb.EchoRequest{Message: message})
   if err != nil {
      log.Fatalf("client.UnaryEcho(_) = _, %v: ", err)
   }
   fmt.Println("UnaryEcho: ", resp.Message)
}
​
func callBidiStreamingEcho(client ecpb.EchoClient) {
   ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
   defer cancel()
   c, err := client.BidirectionalStreamingEcho(ctx)
   if err != nil {
      return
   }
   for i := 0; i < 5; i++ {
      if err := c.Send(&ecpb.EchoRequest{Message: fmt.Sprintf("Request %d", i+1)}); err != nil {
         log.Fatalf("failed to send request due to error: %v", err)
      }
   }
   c.CloseSend()
   for {
      resp, err := c.Recv()
      if err == io.EOF {
         break
      }
      if err != nil {
         log.Fatalf("failed to receive response due to error: %v", err)
      }
      fmt.Println("BidiStreaming Echo: ", resp.Message)
   }
}
​
func main() {
   conn, err := grpc.Dial("127.0.0.1:8990",grpc.WithInsecure(),
      grpc.WithUnaryInterceptor(unaryInterceptor),
      grpc.WithStreamInterceptor(streamInterceptor))
   if err != nil {
      log.Fatalf("did not connect: %v", err)
   }
   defer conn.Close()
​
   rgc := ecpb.NewEchoClient(conn)
   callUnaryEcho(rgc, "hello world")
   callBidiStreamingEcho(rgc)
}

拦截器中的常见操作

在拦截器中，你可以执行多种操作，包括但不限于：

  • 读取和修改元数据（headers）
  • 记录请求和响应的详细信息
  • 执行身份验证和授权检查
  • 添加额外的请求或响应处理逻辑，如加密、解密、压缩、解压缩等
  • 监控RPC调用的性能指标，如延迟、吞吐量等

拦截器可以用来执行以下任务：

  • 修改请求和响应数据：拦截器可以在请求被处理程序处理之前或响应被发送回客户端之前修改请求或响应数据。
  • 处理异常情况：当请求或响应出现异常时，拦截器可以用来处理或记录这些异常。
  • 自定义监控和日志：通过在拦截器中记录日志或生成度量标准，你可以更容易地监控系统的性能和行为。
  • 实现AOP（面向切面编程）概念：拦截器允许你定义跨多个服务和方法的通用逻辑，例如日志记录、安全检查等。

4 总结

通过自定义gRPC拦截器，你可以在不修改服务或客户端代码的情况下，增强gRPC应用程序的功能和安全性。拦截器提供了一种灵活且强大的机制来插入自定义逻辑，并允许你在RPC调用的关键点上执行必要的操作。

相关推荐
幼儿园老大*9 小时前
Go的环境搭建以及GoLand安装教程
开发语言·经验分享·后端·golang·go
童先生16 小时前
Go 项目中实现类似 Java Shiro 的权限控制中间件?
开发语言·go
幼儿园老大*18 小时前
走进 Go 语言基础语法
开发语言·后端·学习·golang·go
架构师那点事儿1 天前
golang 用unsafe 无所畏惧，但使用不得到会panic
架构·go·掘金技术征文
于顾而言2 天前
【笔记】Go Coding In Go Way
后端·go
qq_172805592 天前
GIN 反向代理功能
后端·golang·go
follycat2 天前
2024强网杯Proxy
网络·学习·网络安全·go
OT.Ter2 天前
【力扣打卡系列】单调栈
算法·leetcode·职场和发展·go·单调栈
探索云原生2 天前
GPU 环境搭建指南：如何在裸机、Docker、K8s 等环境中使用 GPU
ai·云原生·kubernetes·go·gpu
OT.Ter2 天前
【力扣打卡系列】移动零（双指针）
算法·leetcode·职场和发展·go
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【TC3xx芯片】TC3xx芯片电源管理系统PMS详解05基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测06【经验分享】Ubuntu22.04安装微信(linux官方版)07文件或文件夹名称中有空格如何批量去除08RAG 实践- Ollama+RagFlow 部署本地知识库09Windows10安装PCL1.14.0及点云配准10Macbook pro M1 安装Ubuntu教程