gRPC 进阶——Interceptor 拦截器

gRPC拦截器是一种用于在RPC方法调用的生命周期中拦截和处理请求和响应的机制。拦截器允许开发者在请求到达实际服务方法之前或在响应返回客户端之前执行自定义逻辑。它们类似于中间件，广泛应用于日志记录、身份验证、请求修改等场景。

拦截器的种类

客户端拦截器（Client Interceptors）

客户端拦截器在客户端发出请求和接收响应时进行拦截。它们常用于添加认证信息、日志记录、修改请求等。

服务器拦截器（Server Interceptors）

服务器拦截器在服务器接收请求和发送响应时进行拦截。它们常用于验证身份、记录日志、修改响应等。

使用场景

日志记录

拦截器可以记录每个请求的详细信息，包括方法名、请求参数、响应结果和处理时间等。

身份验证

在请求到达实际服务方法之前，通过拦截器验证身份信息，确保请求来自合法客户端。

错误处理

拦截器可以捕获和处理请求过程中发生的错误，返回统一的错误响应。

请求和响应修改

拦截器可以在请求到达服务方法之前或响应返回客户端之前对其进行修改，例如添加或移除某些字段。

拦截器使用示例

0.目录树如下

以grpc入门的代码作为示例：

.
├── client
│   └── client.go
├── proto
│   ├── helloworld_grpc.pb.go
│   ├── helloworld.pb.go
│   └── helloworld.proto
└── server
    └── server.go

1. proto文件

syntax = "proto3";

option go_package = "grpc/proto";

service Hello {
  rpc Hello(HelloRequest) returns (HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string response = 1;
}

利用命令生成对应的go文件

cd proto/
protoc meta.proto --go_out=. --go-grpc_out=.

2.服务端拦截器

1.建立server/server.go

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"net"

	"go-try/grpc_interceptor/proto"
)

type HelloServer struct {
	proto.UnimplementedHelloServer
}

func (s *HelloServer) Hello(ctx context.Context, request *proto.HelloRequest) (*proto.HelloResponse, error) {
	return &proto.HelloResponse{
		Response: "Hello " + request.Name,
	}, nil
}

func main() {
	// 定义一个UnaryServerInterceptor
	interceptor := func(ctx context.Context, req any,
		info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp any, err error) {
		// 接收到请求后的逻辑
		fmt.Println("接收到了一个新的请求")
		// 调用原始的handler处理请求
		response, _ := handler(ctx, req)
		// 请求处理完成后的逻辑
		fmt.Println("请求已经完成")
		// 返回处理结果和nil错误
		return response, nil
	}

	// 将定义的拦截器设置到gRPC服务器的选项中
	opts := grpc.UnaryInterceptor(interceptor)

	server := grpc.NewServer(opts)
	proto.RegisterHelloServer(server, &HelloServer{})
	listen, err := net.Listen("tcp", "0.0.0.0:8080")
	if err != nil {
		panic("faild to listen : " + err.Error())
	}
	err = server.Serve(listen)
	if err != nil {
		panic("faild to start grpc : " + err.Error())
	}
}

2.建立client/client.go

package main

import (
	"context"
	"fmt"

	"google.golang.org/grpc"

	"go-try/grpc_interceptor/proto"
)

func main() {
	conn, err := grpc.NewClient("0.0.0.0:8080", grpc.WithInsecure())
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	cli := proto.NewHelloClient(conn)
	msg, err := cli.Hello(context.Background(), &proto.HelloRequest{Name: "zs"})
	if err != nil {
		panic(err)
	}
	fmt.Println(msg)
}

3. 分别运行server.go和client.go

server端运行结果如下：

接收到了一个新的请求
请求已经完成

3.客户端拦截器

1. 修改client/client.go的main函数

func main() {
	interceptor := func(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...)
        // 发起请求之后的逻辑
		fmt.Println("耗时: %s", time.Since(start))
		return err
	}

	var opts []grpc.DialOption
	opts = append(opts, grpc.WithInsecure())
	opts = append(opts, grpc.WithUnaryInterceptor(interceptor))

	conn, err := grpc.NewClient("0.0.0.0:8080", opts...)
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	cli := proto.NewHelloClient(conn)
	msg, err := cli.Hello(context.Background(), &proto.HelloRequest{Name: "zs"})
	if err != nil {
		panic(err)
	}
	fmt.Println(msg)
}

2.分别运行server.go和client.go

client端运行结果如下：

请求耗时: %s 1.487169ms

拦截器应用场景

开源项目：go-grpc-middleware

总结

gRPC 拦截器是一种用于在 RPC 调用的生命周期中拦截和处理请求与响应的机制，类似于中间件。它们广泛应用于日志记录、身份验证、错误处理和请求修改等场景，能够在请求到达实际服务方法之前或响应返回客户端之前执行自定义逻辑，从而提高系统的灵活性和可维护性。拦截器有客户端和服务器两种类型，可以帮助开发者简化代码、增强功能，但也可能增加一些性能开销。