gRPC是微软在.NET Core 及其后续版本中主推的 RPC 框架，它使用 Google 的 Protocol Buffers 作为序列化协议，使用 HTTP/2 作为通信协议，具有跨语言、高性能、双向流式调用等优点。考虑到，接下来要参与的是，一个以gRPC为核心而构建的微服务项目。因此，博主准备调研一下gRPC的相关内容，而首当其冲的，则是从 .NET Core 3.1 开始就有的拦截器，它类似于ASP.NET Core中的过滤器和中间件，体现了一种面向切面编程(AOP)的思想，非常适合在 RPC 服务调用的时候做某种统一处理，譬如参数校验、身份验证、日志记录等等。在今天这篇博客中，博主主要和大家分享的是，利用 .NET Core gRPC 中的拦截器实现日志记录的简单技巧，希望能给大家带来一点启发。

关于 Interceptor 类

Interceptor类是 gRPC 服务拦截器的基类，它本身是一个抽象类，其中定义了下面的虚方法：

1public virtual AsyncClientStreamingCall<TRequest, TResponse> AsyncClientStreamingCall<TRequest, TResponse>();
2public virtual AsyncDuplexStreamingCall<TRequest, TResponse> AsyncDuplexStreamingCall<TRequest, TResponse>();
3public virtual AsyncUnaryCall<TResponse> AsyncUnaryCall<TRequest, TResponse>();
4public virtual TResponse BlockingUnaryCall<TRequest, TResponse>();
5public virtual Task<TResponse> ClientStreamingServerHandler<TRequest, TResponse>();
6public virtual AsyncServerStreamingCall<TResponse> AsyncServerStreamingCall<TRequest, TResponse>();
7public virtual Task DuplexStreamingServerHandler<TRequest, TResponse>();
8public virtual Task ServerStreamingServerHandler<TRequest, TResponse>();
9public virtual Task<TResponse> UnaryServerHandler<TRequest, TResponse>();

整体而言，如果从通信方式上来划分，可以分为：流式调用 和 普通调用；而如果从使用方来划分，则可以分为：客户端 和 服务端。进一步讲的话，针对流式调用，它还分为："单向流" 和 “双向流"。关于这些细节上的差异，大家可以通过 gRPC 的官方文档来了解，这里我们给出的是每一种方法对应的用途：

方法名	描述
AsyncClientStreamingCall	拦截异步客户端流式调用
AsyncDuplexStreamingCall	拦截双向流式调用
AsyncUnaryCall	拦截异步普通调用
BlockingUnaryCall	拦截阻塞普通调用
AsyncServerStreamingCall	拦截异步服务端流式调用
ClientStreamingServerHandler	拦截客户端流式调用的服务端处理程序
DuplexStreamingServerHandler	拦截双向流式调用的服务端处理程序
ServerStreamingServerHandler	拦截服务端流式调用的服务端处理程序
UnaryServerHandler	拦截普通调用的服务端处理程序

实现一个拦截器

好了，下面我们一起实现一个拦截器。这里，我们使用的是微软官方的例子：

 1public class GreeterService : Greeter.GreeterBase
 2{
 3    private readonly ILogger<GreeterService> _logger;
 4    public GreeterService(ILogger<GreeterService> logger)
 5    {
 6        _logger = logger;
 7    }
 8
 9    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
10    {
11        return Task.FromResult(new HelloReply
12        {
13            Message = "Hello " + request.Name
14        });
15    }
16}

服务器端

实现服务器端的普通调用拦截，我们需要重写的方法是UnaryServerHandler:

 1public class GRPCServerLoggingInterceptor : Interceptor
 2{
 3    private readonly ILogger<GRPCServerLoggingInterceptor> _logger;
 4    public GRPCServerLoggingInterceptor(ILogger<GRPCServerLoggingInterceptor> logger)
 5    {
 6        _logger = logger;
 7    }
 8    
 9    // 重写 UnaryServerHandler() 方法
10    public override Task<TResponse> UnaryServerHandler<TRequest, TResponse>(
11      TRequest request, ServerCallContext context, 
12      UnaryServerMethod<TRequest, TResponse> continuation
13    )
14    {
15        var builder = new StringBuilder();
16
17        // Call gRPC begin
18        builder.AppendLine($"Call gRPC {context.Host}/{context.Method} begin.");
19
20        // Logging Request
21        builder.AppendLine(LogRequest(request));
22
23        // Logging Response
24        var reply = continuation(request, context);
25        var response = reply.Result;
26        var exception = reply.Exception;
27        builder.AppendLine(LogResponse(response, exception));
28
29        // Call gRPC finish
30        builder.AppendLine($"Call gRPC {context.Host}/{context.Method} finish.");
31        _logger.LogInformation(builder.ToString());
32
33        return reply;
34    }
35    
36    // 记录gRPC请求
37    private string LogRequest<TRequest>(TRequest request)
38    {
39        var payload = string.Empty;
40        if (request is IMessage)
41            payload = JsonConvert.SerializeObject(
42                (request as IMessage)
43                .Descriptor.Fields.InDeclarationOrder()
44                .ToDictionary(x => x.Name, x => x.Accessor.GetValue(request as IMessage))
45            );
46        return $"Send request of {typeof(TRequest)}:{payload}";
47    }
48    
49    // 记录gRPC响应
50    private string LogResponse<TResponse>(TResponse response, AggregateException exception)
51    {
52        var payload = string.Empty;
53        if (exception == null)
54        {
55            if (response is IMessage)
56                payload = JsonConvert.SerializeObject(
57                  (response as IMessage)
58                  .Descriptor.Fields.InDeclarationOrder()
59                  .ToDictionary(x => x.Name, x => x.Accessor.GetValue(response as IMessage))
60                );
61            return $"Receive response of {typeof(TResponse)}:{payload}";
62        }
63        else
64        {
65            var errorMsgs = string.Join(";", exception.InnerExceptions.Select(x => x.Message));
66            return $"Receive response of {typeof(TResponse)} throws exceptions: {errorMsgs}";
67        }
68    }
69}

对于gRPC而言，每一个由.proto声明文件生成的类，都带有一个叫做Descriptor的属性，我们可以利用这个属性获得gRPC请求和响应的详细信息。所以，在LogRequest()和LogResponse()两个方法中，我们均使用了这一思路来记录gRPC的报文信息，因为传输层的gRPC使用了二进制作为数据载体，这可以说是一种用可读性换取高效率的做法，不过幸运的是，我们在这里实现了这个小目标。

接下来，为了让这个拦截器真正生效，我们还需要修改一下Startup类中注册gRPC这部分的代码：

1services.AddGrpc(options => options.Interceptors.Add<GRPCServerLoggingInterceptor>());

此时，我们可以得到下面的结果：

客户端

实现客户端的普通调用拦截，我们需要重写的方法是AsyncUnaryCall()，依样画葫芦即可：

 1public class GRPCClientLoggingInterceptor : Interceptor
 2{
 3    // 重写 AsyncUnaryCall() 方法
 4    public override AsyncUnaryCall<TResponse> AsyncUnaryCall<TRequest, TResponse>(
 5        TRequest request,
 6        ClientInterceptorContext<TRequest, TResponse> context,
 7        AsyncUnaryCallContinuation<TRequest, TResponse> continuation
 8    )
 9    {
10        var builder = new StringBuilder();
11
12        // Call gRPC begin
13        builder.AppendLine($"Call gRPC {context.Host}/{context.Method} begin.");
14
15        // Logging Request
16        builder.AppendLine(LogRequest(request));
17
18        // Logging Response
19        var reply = continuation(request, context);
20        var response = reply.ResponseAsync.Result;
21        var exception = reply.ResponseAsync.Exception;
22        builder.AppendLine(LogResponse(response, exception));
23
24        // Call gRPC finish
25        builder.AppendLine($"Call gRPC {context.Host}/{context.Method} finish.");
26        Console.WriteLine(builder.ToString());
27
28        return reply;
29    }
30}

类似地，为了让拦截器在客户端生效，我们需要这样：

1using Grpc.Core.Interceptors;
2
3var channel = GrpcChannel.ForAddress("https://localhost:5001");
4// 简化写法
5channel.Intercept(new GRPCClientLoggingInterceptor());
6// 完整写法
7var invoker = channel.CreateCallInvoker().Intercept(new GRPCClientLoggingInterceptor());
8var client = new Greeter.GreeterClient(invoker);
9await client.SayHelloAsync(new HelloRequest() { Name = "长安书小妆" });

此时，我们可以得到下面的结果：

客户端感觉不太好的一点就是，这个Interceptor传入的必须是一个实例，考虑到拦截器内部可能会依赖类似ILogger等等的组件，建议还是通过IoC容器来取得一个拦截器的实例，然后再传入Intercept()方法中。博主所在的项目中，则是非常“土豪”地使用了PostSharp，直接走动态编织的方案，果然，“这次第，怎一个羡字了得”。当然，gRPC的客户端，其实提供了日志相关的支持，不过，我个人感觉这个有一点无力：

1var loggerFactory = LoggerFactory.Create(logging =>
2{
3    logging.AddConsole();
4    logging.SetMinimumLevel(LogLevel.Debug);
5});
6var channel = GrpcChannel.ForAddress(
7    "https://localhost:5001",
8    new GrpcChannelOptions { LoggerFactory = loggerFactory }
9);

本文小结

本文主要分享了gRPC拦截器的使用技巧，gRPC支持一元调用(UnaryCall)、流式调用(StreamingCall)、阻塞调用(BlockingCall)，因为区分客户端和服务器端，所以，实际上会有各种各样的组合方式。gRPC的拦截器实际上就是选择对应的场景去重写相应的方法，其中，拦截器的基类为Interceptor类，这里我们都是以普通的一元调用为例的，大家可以结合各自的业务场景，去做进一步的调整和优化。这里，我们使用IMessage类的Descriptor属性来“反射”报文中定义的字段，这样就实现了针对gRPC服务请求/响应的日志记录功能。关于gRPC中日志和诊断的更进一步的话题，大家可以参考微软的官方文档。好了，以上就是这篇博客的全部内容啦，谢谢大家！