NET Core使用Grpc通信（一）：一元请求

出轨者千刀万剐

gRPC是一个现代的开源高性能远程过程调用(RPC)框架，它可以高效地连接数据中心内和跨数据中心的服务，支持负载平衡、跟踪、运行状况检查和身份验证。
gRPC通过使用 Protocol Buffers 作为数据传输格式，实现了在不同平台上的通信，并支持双向流和流式传输。RPC 是远程过程调用的缩写，实现跨服务器调用。在开发中，规定调用规则、网络传输协议以及数据序列化反序列化规范是确保前后端通信规范性的关键。
了解GRpc前需要了解Rpc概念。
什么是 RPC 

RPC 是 Remote Procedure Call 的简称，中文叫远程过程调用。
说的白话一点，可以这么理解：比如有两台服务器A和B，A服务器上的应用想调用B服务器上的另一个应用提供的方法，但由于不在同一个内存空间，无法直接调用，所以需要通过网络来实现调用效果。
其实大家在平时开发中有接触过，例如：前端去请求后端的接口。我们来想一下前后端要制定什么规则，才能进行接口请求：

• 调用的语义，也可以理解为接口规范。(比如 RESTful )
  
• 网络传输协议 (比如 HTTP )
  
• 数据序列化反序列化规范(比如 JSON )
  

只有制定了这些规则，才能保证前后端通信的规范性

交互图
从上图中可以看出，RPC 是一种客户端-服务端（Client/Server）模式。从某种角度来看，所有本身应用程序之外的调用都可以归类为 RPC。无论是微服务、第三方 HTTP 接口，还是读写数据库中间件 Mysql、Redis。
RPC 特点

• RPC 是一种协议。RPC实现包括：Dubbo、Thrift、Grpc、Netty等。
  
• 网络协议和网络 IO 模型对其透明。RPC 的客户端认为自己是在调用本地对象，因此其对使用的网络协议（ HTTP 协议等）以及网络 IO 模型，是不关心的。
  
• 信息格式对其透明。调用方法是需要传递参数的，对于远程调用来说，传递过程中参数的信息格式是怎样构成，以及提供者如何使用这些参数，都是不用关心的。
  
• 有跨语言能力。因为调用方实际上也不清楚远程服务器的应用程序是使用什么语言运行的。那么对于调用方来说，无论服务器方使用的是什么语言，本次调用都应该成功，并且返回值也应该按照调用方程序语言所能理解的形式进行描述。
  

RPC 与 HTTP 的对比

其实 RPC 跟 HTTP 不是一个层级的东西，RPC 应该是跟 HTTP + RestFul 进行对比。
深入了解：HTTP 与 RPC 接口区别
传输协议

RPC 可以基于 HTTP 或者 TCP 进行传输，而 HTTP 只能基于 HTTP
传输效率

RPC 包含了 HTTP2 的优点，所以他的传输效率比 HTTP1 更高~
性能消耗

RPC 包含 HTTP2 的优点，比如二进制传输、头部压缩等，所以性能消耗自然比 HTTP1 低~
负载均衡

RPC 基本都自带负载均衡策略，而 HTTP 需要配置 Nginx/HAProxy 来完成
服务治理

RPC 能做到自动通知，不影响上游，而 HTTP 需要事先通知，修改 Nginx/HAProxy 配置
gRPC 和 RPC 的关系

Grpc 是由谷歌开源的一种 RPC 框架，设计之初便是为了解决谷歌内部的 RPC 使用场景所遇到的问题。因此你可以说 gRPC 就是一种 RPC 框架类型。具体来说:

• RPC是一种编程范式,定义了客户端像调用本地函数一样调用远程函数的方式。
  
• gRPC 是 Google 基于 HTTP/2 和 Protocol Buffers 实现的 RPC 框架。
  
• gRPC 支持双向流、流控、头压缩等,性能优异。
  

所以 gRPC 是  RPC 模式的一种高效实现，提供了语言中立、高性能、安全的 RPC 服务框架，使得RPC服务调用更加高效、简单、通用。它是 RPC 模式的一种优秀代表。
gRPC 的优势有哪些？

gRPC 是基于 HTTP/2 设计的~所以 gRPC 的优点自然也包含了 HTTP/2 的优点：

• 数据传输二进制分帧
  
• 多路复用
  
• 服务端推送
  
• 头部压缩
  

gRPC的主要优势及其简要描述：

优势	描述
高性能	利用HTTP/2提供高效的网络传输，支持双向流、头部压缩、多路复用。
跨语言支持	支持多种编程语言间的无缝通信和集成。
自动化生成代码	使用Protobuf定义服务，自动生成客户端和服务器代码。
错误处理	定义丰富的错误码和状态码，便于异常处理和调试。
通信模式多样	支持多种RPC通信模型，如一对一、服务端流、客户端流、双向流等。
可扩展性	拦截器和插件机制允许功能的扩展和定制。
社区和生态系统	拥有活跃的社区支持和丰富的相关工具及库。

 
gRPC 是怎么传输的？

服务端 Stub 接收客户端请求,处理请求中的 Protobuf 数据并进行反序列化，然后将请求对象传入服务器并实现业务逻辑处理。最终再将响应序列化后返回给客户端，从而形成一次完整的接口调用过程。

 
以上概念以及相关知识点来自apifox。
NET Core实现Grpc调用

话不多说，以下内容详细介绍一元调用的过程，贴代码。
-----------------服务端代码 Start-----------------
步骤一：
在Grpc服务端(Server)先创建一个.potos文件。文件名（IBook_Service.proto）文件路径（Protos/IBook_Service.proto）

1. //表明使用protobuf的编译器版本为v2,目前最新的版本为v3。
2. syntax = "proto3";
4. //定义命名空间
5. option csharp_namespace = "ZP_BookService_Grpc.Application.Book_Service";
7. //包名：多个 .proto 文件生成代码时，可避免命名冲突。
8. package Book_Service;
10. //1、定义接口名称，用于后期实现
11. service IBook_Service{
13. // 1.1 根据商品主键，获取商品
14. rpc GetBook (BookFrom) returns (BookDto);
15. }
17. // 2、定义入参(类)Form：顺序要写，且不能重复
18. message BookFrom{
19.     string BookName = 1;
20. }
22. // 3、定义出参Dto(类)：顺序要写，且不能重复
23. message BookDto{
24.     string ID = 1;
25.     string CreateTime = 2;
26.     string BookName = 3;
27.     string BookPrice =4;
28.     string PublicationDate = 5;
29.     string Type = 6;
30.     string Publisher = 7;
31.     int32  Residue = 8;
32. }

复制代码

步骤二：
文件建立好后需要在项目的Project内加上文件的目录（Protos\IBook_Service.prot） GrpcServices意思是服务端，一定要加上
引用包（Google.Protobuf、Grpc.AspNetCore、Grpc.Tools）
完成以上步骤，右键项目选择 “重新生成”。生成以后可以在项目的obj文件夹（~\Application_Grpc\obj\Debug\net7.0\Protos）看到一个自动生成的Protos文件夹

1. <ItemGroup>
2.     <PackageReference Include="Google.Protobuf" Version="3.26.0" />
3.     <PackageReference Include="Grpc.AspNetCore" Version="2.61.0" />
4.     <PackageReference Include="Grpc.Tools" Version="2.62.0" />
5. </ItemGroup>
6. <ItemGroup>
7.         <Protobuf Include="Protos\IBook_Service.proto" GrpcServices="Server" />
8. </ItemGroup>

复制代码

步骤三：
创建一个实现类（Book_Service）用于实现protos文件夹内自动生成的接口（IBook_Service.IBook_ServiceBase）。注：实现带有Base的接口。接口名称是定义proto文件的时候自定义的。

1. namespace Application_Grpc.Application.BusinessServices
2. {
3.     //注入作用域生命周期
4.     [Service(ServiceLifetime.Scoped)]
5.     public class Book_Service : IBook_Service.IBook_ServiceBase
6.     {
7.         private IBook_Repository _bookRepository { get; }
8.         private IMapper _mapper { get; }
9.         public Book_Service(IBook_Repository book_Repository, IMapper mapper)
10.         {
11.             _bookRepository = book_Repository;
12.             _mapper = mapper;
13.         }
14.         public override async Task<BookDto> GetBook(BookFrom request, ServerCallContext context)
15.         {
16.             BookDto data=new BookDto();
17.             data.ID = Guid.NewGuid().ToString();
18.             data.CreateTime = DateTime.Now.ToString();
19.             data.BookName = request.BookName;
20.             data.BookPrice = "29.99";
21.             data.PublicationDate = "1999-03-21";
22.             data.Type = "经典";
23.             data.Publisher = "清华大学出版社";
24.             data.Residue = 5;
25.             return data;
26.         }
27.     }
28. }

复制代码

至此，服务端的Grpc就完成了。剩下的就是把项目进行服务依赖注入操作，本实例代码通过贴特征方式注入。可以在 Program.cs 以常规方式注入自己的服务。
如：builder.Services.AddSingleton();
-----------------服务端代码 END-----------------
-----------------客户端代码 Start-----------------
步骤一：
步骤一：
在Grpc服务端(Client)先创建一个.potos文件。文件名（IBook_Service.proto）文件路径（Protos/IBook_Service.proto）。其实就是复制服务端的 proto 修改下 命名空间

1. //表明使用protobuf的编译器版本为v2,目前最新的版本为v3。
2. syntax = "proto3";
4. //定义命名空间
5. option csharp_namespace = "ZP_ProjectEntrance.MicroService.Book_Service";
7. //包名：多个 .proto 文件生成代码时，可避免命名冲突。
8. package Book_Service;
10. //1、定义接口名称，用于后期实现
11. service IBook_Service{
13. // 1.1 根据商品主键，获取商品
14. rpc GetBook (BookFrom) returns (BookDto);
15. }
17. // 2、定义入参(类)Form：顺序要写，且不能重复
18. message BookFrom{
19.     string BookName = 1;
20. }
22. // 3、定义出参Dto(类)：顺序要写，且不能重复
23. message BookDto{
24.     string ID = 1;
25.     string CreateTime = 2;
26.     string BookName = 3;
27.     string BookPrice =4;
28.     string PublicationDate = 5;
29.     string Type = 6;
30.     string Publisher = 7;
31.     int32  Residue = 8;
32. }

复制代码

步骤二：
文件建立好后需要在项目的加上文件的目录（Protos\IBook_Service.prot） GrpcServices意思是客户端（Client），一定要加上
引用包（Google.Protobuf、Grpc.AspNetCore、Grpc.Tools）
完成以上步骤，右键项目选择 “重新生成”。生成以后可以在项目的obj文件夹（~\ZP_ProjectEntrance\obj\Debug\net7.0\Protos）看到一个自动生成的Protos文件夹

1. <ItemGroup>
2.     <PackageReference Include="Google.Protobuf" Version="3.26.0" />
3.     <PackageReference Include="Grpc.AspNetCore" Version="2.61.0" />
4.     <PackageReference Include="Grpc.Tools" Version="2.62.0" />
5. </ItemGroup>
6. <ItemGroup>
7.         <Protobuf Include="Protos\IBook_Service.proto" GrpcServices="Server" />
8. </ItemGroup>

复制代码

步骤三：重点、重点、重点~
创建一个客户端类（ClientHelper）用于对接到Grpc的服务端，通过Func型委托形式构建，做成公共的请求服务端入口。

1. public static class GrpcClientHelper
2. {
3.     /// <summary>
4.     /// 一元rpc调用
5.     /// </summary>
6.     /// <typeparam name="TClient">客户端类型</typeparam>
7.     /// <typeparam name="TRequest">请求类型  </typeparam>
8.     /// <typeparam name="TResponse">服务端响应返回类型</typeparam>
9.     /// <typeparam name="TResult">方法返回类型 </typeparam>
10.     /// <param name="serverAddress">请求服务端地址</param>
11.     /// <param name="callFunc">异步调用 gRPC方法的委托 </param>
12.     /// <param name="request">封装请求对象(数据)</param>
13.     /// <param name="clientFactory">创建 gRPC 客户端的委托工厂方法  </param>
14.     /// <returns></returns>
15.     public static async Task<TResult> CallGrpcServiceAsync<TClient, TRequest, TResponse, TResult>(
16.         string serverAddress, Func<TClient, TRequest, Task<TResponse>> callFunc, TRequest request, Func<GrpcChannel, TClient> clientFactory)
17.         where TClient : class
18.         where TRequest : class
19.         where TResponse : class
20.     {
21.         using var channel = GrpcChannel.ForAddress(serverAddress);
22.         var client = clientFactory(channel);
23.         try
24.         {
25.             var response = await callFunc(client, request);
26.             // 这里添加转换逻辑，如果 TResponse 不是 TResult,强制类型转换，需要确保类型兼容
27.             return (TResult)(object)response;
28.         }
29.         catch (RpcException)
30.         {
31.             // 处理异常  
32.             throw;
33.         }
34.     }
35.     /// <summary>
36.     /// 获取某个字段的值
37.     /// </summary>
38.     /// <typeparam name="Source"></typeparam>
39.     /// <param name="source"></param>
40.     /// <param name="field"></param>
41.     /// <returns></returns>
42.     public static object GetFieldValue<Source>(Source source, string field)
43.     {
44.         var fieldProperty = source.GetType().GetProperty(field);
45.         if (fieldProperty != null)
46.             return fieldProperty.GetValue(source);
47.         else
48.             return null;
49.     }
50. }

复制代码

 步骤四：
通过Controllers定义的方法，以请求方法形式进行调用到GrpcClientHelper

1. namespace ZP_ProjectEntrance.Controllers
2. {
3.     [Route("api/[controller]")]
4.     [ApiController]
5.     public class BooKController : ControllerBase
6.     {
7.         private readonly ILogger<BooKController> _logger;
8.         public BooKController(ILogger<BooKController> logger)
9.         {
10.             _logger = logger;
11.         }
12.         /// <summary>
13.         /// 获取书籍信息
14.         /// </summary>
15.         /// <returns></returns>
16.         [HttpGet(Name = "GetBook")]
17.         public async Task<BookDto> GetBookAsync()
18.         {
19.             // 服务端地址，可以扩展为请求分布式集群
20.             string serverAddress = "http://localhost:5031";
21.             // 使用 GrpcClientHelper 来调用 gRPC 服务 ,  
22.             BookDto bookDto = await GrpcClientHelper.CallGrpcServiceAsync<IBook_Service.IBook_ServiceClient, BookFrom, BookDto, BookDto>(
23.                 serverAddress,
24.                 async (client, request) => await client.GetBookAsync(request),  // 异步调用 gRPC 方法的委托  
25.                 new BookFrom { BookName = "三国演义" },                          // 封装请求对象(值)
26.                 (channel) => new IBook_Service.IBook_ServiceClient(channel)     // 实现 gRPC 客户端的委托方法  
27.             );
28.             _logger.LogInformation(JsonConvert.SerializeObject(bookDto));
29.             return bookDto;
30.         }
31.     }
32. }

复制代码

至此，客户端的Grpc就完成了。
-----------------客户端代码 END-----------------
项目的结构

附：贴特征形式实现依赖注入的代码，通过反射机制实现。
注：业务层和仓储层必须是独立层项目，或相同形式进行隔离(要么统一接口I_BLL、I_DLL，要么单纯的BLL、DLL)，否则自行对自动注册类进行改造。
代码可以写在公共层 ExternalService 项目中，作为基础服务进行引用。

1. using Microsoft.Extensions.DependencyInjection;
2. using System.Reflection;
4. namespace ExternalService.RegisterServices
5. {
6.     /// <summary>
7.     /// 通过反射机制自动化进行依赖注入服务
8.     /// </summary>
9.     public static class ServiceCollectionExtension
10.     {
11.         /// <summary>
12.         /// 注册接口类型服务，继承接口（贴特征）
13.         /// </summary>
14.         /// <param name="services">this服务</param>
15.         /// <param name="assembly">程序集</param>
16.         /// <returns></returns>
17.         public static IServiceCollection RegisterIntfaceTypeService(this IServiceCollection services, Assembly assembly)
18.         {
19.             var interfaces = assembly.GetTypes().Where(t => t.IsInterface).ToList();
20.             var types = assembly.GetTypes().Where(t => t.IsClass).ToList();
22.             foreach (var interf in interfaces)
23.             {
24.                 if (interf == null)
25.                     continue;
27.                 var type = types.FirstOrDefault(interf.IsAssignableFrom);
28.                 if (type == null)
29.                     continue;
31.                 var liftTime = ServiceLifetime.Scoped;
32.                 var attr = type.GetCustomAttribute<ServiceAttribute>();
33.                 if (attr != null)
34.                     liftTime = attr.LifeTime;
35.                 else
36.                     continue;
38.                 switch (liftTime)
39.                 {
40.                     default:
41.                     case ServiceLifetime.Scoped:
42.                         {
43.                             //作用生命周期：同一请求之间状态共享，跟随HTTP请求生命周期
44.                             services.AddScoped(interf, type);
45.                             break;
46.                         }
47.                     case ServiceLifetime.Transient:
48.                         {
49.                             //瞬时生命周期：无状态化，每次使用是 new ()
50.                             services.AddTransient(interf, type);
51.                             break;
52.                         }
53.                     case ServiceLifetime.Singleton:
54.                         {
55.                             //单例生命周期：整个程序所有请求状态共享，整个程序只有一个实例
56.                             services.AddSingleton(interf, type);
57.                             break;
58.                         }
59.                 }
60.             }
61.             return services;
62.         }
63.         /// <summary>
64.         /// 注册普通类服务，非接口类型（贴特征）
65.         /// </summary>
66.         /// <param name="services">this服务</param>
67.         /// <param name="assembly">程序集</param>
68.         /// <param name="NamespaceKeyWord">命名空间关键字</param>
69.         /// <returns></returns>
70.         public static IServiceCollection RegisterClassService(this IServiceCollection services, Assembly assembly, string NamespaceKeyWord = "")
71.         {
72.             var ClassTypes = assembly.GetTypes().Where(t => t.IsClass && !t.IsAbstract).ToList();
73.             if (!string.IsNullOrEmpty(NamespaceKeyWord))
74.                 ClassTypes = assembly.GetTypes().Where(t => t.Name.Contains(NamespaceKeyWord)).ToList();
75.             foreach (var types in ClassTypes)
76.             {
77.                 if (types == null)
78.                     continue;
80.                 var liftTime = ServiceLifetime.Scoped;
81.                 var attr = types.GetCustomAttribute<ServiceAttribute>();
82.                 if (attr != null)
83.                     liftTime = attr.LifeTime;
84.                 else
85.                     continue;
87.                 switch (liftTime)
88.                 {
89.                     default:
90.                     case ServiceLifetime.Scoped:
91.                         {
92.                             //作用生命周期：同一请求之间状态共享，跟随HTTP请求生命周期
93.                             services.AddScoped(types);
94.                             break;
95.                         }
96.                     case ServiceLifetime.Transient:
97.                         {
98.                             //瞬时生命周期：无状态化，每次使用是 new ()
99.                             services.AddTransient(types);
100.                             break;
101.                         }
102.                     case ServiceLifetime.Singleton:
103.                         {
104.                             //单例生命周期：整个程序所有请求状态共享，整个程序只有一个实例
105.                             services.AddSingleton(types);
106.                             break;
107.                         }
108.                 }
109.             }
110.             return services;
111.         }
112.     }
114.     /// <summary>
115.     /// 生命周期特征
116.     /// </summary>
117.     [AttributeUsage(AttributeTargets.Class)]
118.     public class ServiceAttribute : Attribute
119.     {
120.         internal ServiceLifetime LifeTime { get; set; }
122.         public ServiceAttribute(ServiceLifetime lifeTime) => LifeTime = lifeTime;
123.     }
124. }

复制代码

在使用的项目程序集内创建一个扩展服务 AddApplication_Register。然后调用注册类扩展服务services.RegisterClassService(Assembly.GetExecutingAssembly());

1. using System.Reflection;
3. using ExternalService.RegisterServices;
4. using Microsoft.Extensions.DependencyInjection;
6. namespace Application_Grpc
7. {
8.     public static class Application_GrpcExtension
9.     {
10.         public static IServiceCollection AddApplication_Register(this IServiceCollection services)
11.         {
12.             services.RegisterClassService(Assembly.GetExecutingAssembly());
13.             return services;
14.         }
15.     }
16. }

复制代码

在Program.cs内注册添加项目程序集的扩展服务，把上面Application_GrpcExtension类的AddApplication_Register进行调用：builder.Services.AddApplication_Register();

来源:https://www.cnblogs.com/LaoPaoEr/p/18105579
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！