SpringBoot整合grpc

Introduction to gRPC | gRPC

一、简介

之所以会说grpc是高性能框架，默认情况下，gRPC基于Netty进行服务端和客户端互通，使用Protocol Buffers进行传输，这是Google用于序列化结构化数据的成熟开源机制，基于proto3情况下它还是一个跨语言的RPC框架（目前支持Java、c++、Dart、Python、Objective-C、c#、lite-runtime (Android Java)、Ruby和JavaScript(来自协议缓冲区GitHub repo)，以及来自golang/protobuf官方包的Go语言生成器） 

如果对grpc不够了解可以参考Introduction to gRPC | gRPC。

 

二、下图是通信流程模型 

• 客户端(gRPC Stub)调用 A 方法，发起 RPC 调用。
• 对请求信息使用 Protobuf 进行对象序列化压缩(IDL)。
• 服务端(gRPC Server)接收到请求后，解码请求体，进行业务逻辑处理并返回。
• 对响应结果使用 Protobuf 进行对象序列化压缩(IDL)。
• 客户端接受到服务端响应，解码请求体。回调被调用的 A 方法，唤醒正在等待响应(阻塞)的客户端调用并返回响应结果。

三、准备

1、PROTOC下载及安装

下载地址

2、准备两个springboot项目，作为服务端和客户端

3、下载Apifox软件，用于直连服务端（可选）

下载地址

 

四、环境搭建

1、服务端server

1）pom文件

1. <!--部分配置-->
2. <dependencies>
3. <dependency>
4. <groupId>org.springframework.boot</groupId>
5. <artifactId>spring-boot-starter</artifactId>
6. </dependency>
7. <dependency>
8. <groupId>io.grpc</groupId>
9. <artifactId>grpc-protobuf</artifactId>
10. <version>${grpc.version}</version>
11. </dependency>
12.  
13. <dependency>
14. <groupId>io.grpc</groupId>
15. <artifactId>grpc-stub</artifactId>
16. <version>${grpc.version}</version>
17. </dependency>
18. <!--gRPC服务端-->
19. <dependency>
20. <groupId>net.devh</groupId>
21. <artifactId>grpc-server-spring-boot-starter</artifactId>
22. <version>2.13.1.RELEASE</version>
23. </dependency>
24.  
25.  
26. </dependencies>
27. <properties>
28. <grpc.version>1.42.1</grpc.version>
29. <protobuf.version>3.7.1</protobuf.version>
30. </properties>
31. <build>
32. <finalName>${project.artifactId}-${project.version}</finalName>
33. <extensions>
34. <extension>
35. <groupId>kr.motd.maven</groupId>
36. <artifactId>os-maven-plugin</artifactId>
37. <version>1.6.2</version>
38. </extension>
39. </extensions>
40.  
41. <plugins>
42. <!-- Grpc coding plug-in-->
43. <plugin>
44. <groupId>org.xolstice.maven.plugins</groupId>
45. <artifactId>protobuf-maven-plugin</artifactId>
46. <version>0.6.1</version>
47. <configuration>
48. <!--suppress UnresolvedMavenProperty -->
49. <!--&lt;!&ndash; ${os.detected.classifier} 变量由${os.detected.name} 和 ${os.detected.arch} 组成-->
50. <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
51. <pluginId>grpc-java</pluginId>
52. <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
53. <!-- protoSourceRoot 默认src/main/proto-->
54. <!-- <protoSourceRoot>src/java/main/proto</protoSourceRoot>-->
55. </configuration>
56. <executions>
57. <execution>
58. <goals>
59. <goal>compile</goal>
60. <goal>compile-custom</goal>
61. </goals>
62. </execution>
63. </executions>
64. </plugin>
65. </plugins>
66. </build>

2）创建proto用于生成proto目标文件

注意：proto文件需要创建在src/main/proto下，因为pom使用的是protoSourceRoot默认路径

创建Simple.proto 

1. syntax = "proto3"; // 协议版本
2.  
3. // 选项配置
4. option java_multiple_files = true;
5. //生成位置
6. option java_package = "com.na.model.proto";
7. option java_outer_classname = "SimpleProto";
8.  
9. service Simple {
10. // 简单gRPC
11. rpc OneToOne (MyRequest) returns (MyResponse) {
12. }
13. }
14.  
15. message MyRequest {
16. string name = 1;
17.  
18. int32 value = 2;
19. }
20.  
21. message MyResponse {
22. string message = 1;
23.  
24. int64 result = 2;
25. }

 生成方式有两种一种是通过命令，这里使用maven插件生成compile和compile-custom

 编译后可在target下看到生成的相应的java类

 3）服务端yml配置

这里只贴出关键代码，其他配置根据实际情况来

1. # gRPC有关的配置，这里只需要配置服务端口号默认9090
2. grpc:
3. server:
4. port: 19898
5. spring:
6. application:
7. name: nacos-grpc

 

4）创建GrpcServerService实现服务端接口

1. package com.na.grpc.server;
2. import com.na.model.proto.MyRequest;
3. import com.na.model.proto.MyResponse;
4. import com.na.model.proto.SimpleGrpc;
5. import io.grpc.stub.StreamObserver;
6. import lombok.extern.slf4j.Slf4j;
7. import net.devh.boot.grpc.server.service.GrpcService;
8.  
9.  
10. /**
11. * GrpcServerService.java中有几处需要注意：
12. *
13. * 是使用@GrpcService注解，再继承SimpleImplBase，这样就可以借助grpc-server-spring-boot-starter库将oneToOne暴露为gRPC服务；
14. *
15. * SimpleImplBase是前文中根据maven compile编译 proto文件自动生成的java代码，
16. *
17. * oneToOne方法中处理完毕业务逻辑后，调用responseObserver.onNext方法填入返回内容；
18. *
19. * 调用responseObserver.onCompleted方法表示本次gRPC服务完成；
20. */
21. @GrpcService
22. @Slf4j
23. public class GrpcServerService extends SimpleGrpc.SimpleImplBase {
24.  
25. @Override
26. public void oneToOne(MyRequest request, StreamObserver<MyResponse> responseObserver) {
27. log.info("接收客户端数据{}", request);
28. MyResponse response = MyResponse.newBuilder().setMessage( request.getName()).build();
29. responseObserver.onNext(response);
30. responseObserver.onCompleted();
31. }
32.  
33. }

2、客户端client

1）pom文件

1. <!--部分配置-->
2. <dependencies>
3. <dependency>
4. <groupId>org.springframework.boot</groupId>
5. <artifactId>spring-boot-starter</artifactId>
6. </dependency>
7. <dependency>
8. <groupId>org.springframework.boot</groupId>
9. <artifactId>spring-boot-starter-web</artifactId>
10. </dependency>
11.  
12. <dependency>
13. <groupId>io.grpc</groupId>
14. <artifactId>grpc-protobuf</artifactId>
15. <version>${grpc.version}</version>
16. </dependency>
17. <dependency>
18. <groupId>io.grpc</groupId>
19. <artifactId>grpc-stub</artifactId>
20. <version>${grpc.version}</version>
21. </dependency>
22. <!--gRPC客户端-->
23. <dependency>
24. <groupId>net.devh</groupId>
25. <artifactId>grpc-client-spring-boot-starter</artifactId>
26. <version>2.14.0.RELEASE</version>
27. </dependency>
28. </dependencies>
29.  
30. <properties>
31. <grpc.version>1.42.1</grpc.version>
32. <protobuf.version>3.7.1</protobuf.version>
33. </properties>
34. <build>
35. <finalName>${project.artifactId}-${project.version}</finalName>
36.  
37. <extensions>
38. <extension>
39. <groupId>kr.motd.maven</groupId>
40. <artifactId>os-maven-plugin</artifactId>
41. <version>1.6.2</version>
42. </extension>
43. </extensions>
44.  
45. <plugins>
46. <!-- Grpc coding plug-in-->
47. <plugin>
48. <groupId>org.xolstice.maven.plugins</groupId>
49. <artifactId>protobuf-maven-plugin</artifactId>
50. <version>0.6.1</version>
51. <configuration>
52. <!--suppress UnresolvedMavenProperty -->
53. <!--&lt;!&ndash; ${os.detected.classifier} 变量由${os.detected.name} 和 ${os.detected.arch} 组成-->
54. <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
55. <pluginId>grpc-java</pluginId>
56. <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
57. <!-- protoSourceRoot 默认src/main/proto-->
58. <!-- <protoSourceRoot>src/java/main/proto</protoSourceRoot>-->
59. </configuration>
60. <executions>
61. <execution>
62. <goals>
63. <goal>compile</goal>
64. <goal>compile-custom</goal>
65. </goals>
66. </execution>
67. </executions>
68. </plugin>
69. </plugins>
70. </build>

2）创建proto用于生成proto目标文件

与服务端操作一样，这里省略。。。。。。

 3）客户端yml配置

这里只贴出关键代码，其他配置根据实际情况来

1. server:
2. port: 11278
3. servlet:
4. context-path: /
5. # grpc配置
6. grpc:
7. # grpc clienT相关配置
8. client:
9. # 服务名（不同服务名可对应不同配置）
10. # nacos-grpc是服务端配置的名字，GrpcClient注解会用到
11. nacos-grpc:
12. # gRPC服务端地址
13. # address: 'dns://127.0.0.1:19898'
14. address: 'static://127.0.0.1:19898'
15. # 是否开启保持连接（长连接）
16. enableKeepAlive: true
17. # 保持连接时长（默认20s）
18. keepAliveTimeout: 20s
19. # 没有RPC调用时是否保持连接（默认false，可禁用避免额外消耗CPU）
20. keepAliveWithoutCalls: false
21. # 客户端负载均衡策略(round_robin（默认）, pick_first)
22. defaultLoadBalancingPolicy: round_robin
23. # 通信类型
24. # plaintext | plaintext_upgrade | tls
25. # 明文通信且http/2 | 明文通信且升级http/1.1为http/2 | 使用TLS（ALPN/NPN）通信
26. negotiationType: plaintext

4）创建GrpcClientService客户端类

1. package com.na.grpc.client;
2.  
3. import com.na.model.proto.MyRequest;
4. import com.na.model.proto.MyResponse;
5. import com.na.model.proto.SimpleGrpc;
6. import io.grpc.StatusRuntimeException;
7. import lombok.extern.slf4j.Slf4j;
8. import net.devh.boot.grpc.client.inject.GrpcClient;
9. import org.springframework.stereotype.Service;
10.  
11. /**
12. * GrpcClientService类有几处要注意的地方：
13. * <p>
14. * 用@Service将GrpcClientService注册为spring的普通bean实例；
15. * <p>
16. * 用@GrpcClient修饰SimpleBlockingStub，这样就可以通过grpc-client-spring-boot-starter库发起gRPC调用，被调用的服务端信息来自名为nacos-grpc服务端配置；
17. * <p>
18. * SimpleBlockingStub来自前文中根据helloworld.proto生成的java代码；
19. * <p>
20. * SimpleBlockingStub.oneToOne方法会远程调用nacos-grpc应用的gRPC服务；
21. */
22. @Service
23. @Slf4j
24. public class GrpcClientService {
25.  
26. @GrpcClient("nacos-grpc")
27. private SimpleGrpc.SimpleBlockingStub simpleStub;
28.  
29. public String oneToOne(final String name) {
30. try {
31. final MyResponse response = this.simpleStub.oneToOne(MyRequest.newBuilder().setName(name).build());
32. return response.getMessage();
33. } catch (final StatusRuntimeException e) {
34. log.error("FAILED with " + e.getStatus().getCode().name() + ",and e:{}", e.getMessage());
35. return "FAILED with " + e.getStatus().getCode().name() + ",and e:" + e.getMessage();
36. }
37. }
38. }
39.  

5)创建SimpleGrpcController

定义了两种连接方法getOneToOne和testForAddress

1. package com.na.controller;
2.  
3. import com.na.base.BaseResponse;
4. import com.na.grpc.client.GrpcClientService;
5. import com.na.model.proto.MyRequest;
6. import com.na.model.proto.SimpleGrpc;
7. import io.grpc.ManagedChannel;
8. import io.grpc.ManagedChannelBuilder;
9. import org.springframework.beans.factory.annotation.Autowired;
10. import org.springframework.web.bind.annotation.GetMapping;
11. import org.springframework.web.bind.annotation.RequestMapping;
12. import org.springframework.web.bind.annotation.RestController;
13.  
14. /**
15. * @Description 测试grpc接口
16. * @Author kele
17. * @Data 2023/9/6 15:35
18. */
19. @RestController
20. @RequestMapping("grpc")
21. public class SimpleGrpcController {
22. @Autowired
23. private GrpcClientService service;
24.  
25. @GetMapping("getOneToOne")
26. public BaseResponse getOneToOne() {
27. return new BaseResponse(service.oneToOne("客户端kele连接"));
28. }
29.  
30.  
31. @GetMapping("testForAddress")
32. public BaseResponse testForAddress() {
33. ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 19898)
34. .usePlaintext()
35. .build();
36. MyRequest request = MyRequest.newBuilder().setName("kele的访问").build();
37. SimpleGrpc.SimpleBlockingStub stub = SimpleGrpc.newBlockingStub(channel);
38. return new BaseResponse(stub.oneToOne(request));
39. }
40.  
41. }

五、启动/测试

1、服务端测试

1）先启动服务端启动的netty端口为19898

2）使用Apifox连接服务端

创建grpc操作文档

可以看到，在Apifox中导入了Simple.proto帮我自动生成了客户端连接操作，自己只需要改一下19898端口和请求的参数

2、客户端测试 

1）启动客户端web端口为11278

2）直接通过web访问

这里访问的是getOneToOne方法， 地址http://localhost:11278/grpc/getOneToOne

另外的testForAddress方法可以自己玩一下生产一般不会那样写

六、问题报错

1、出现无法访问com.google.protobuf.GeneratedMessageV3 找不到com.google.protobuf.GeneratedMessageV，在pom中添加以下依赖。

1. <dependency>
2. <groupId>com.google.protobuf</groupId>
3. <artifactId>protobuf-java</artifactId>
4. <version>${protobuf.version}</version>
5. </dependency>
6. <dependency>
7. <groupId>com.google.protobuf</groupId>
8. <artifactId>protobuf-java-util</artifactId>
9. <version>${protobuf.version}</version>
10. </dependency>

2、出现：io.grpc.StatusRuntimeException: UNAVAILABLE

1、检查下IP是否能ping通，IP、端口 是否正确

2、Server是否打开

3、连接中如果有证书，证书是否有效

4、无证书的，是否写了明文连接，例如：

5、以上都没问题可以查看服务端是否添加了这个依赖，grpc-netty-shaded包中可能会存在core的冲突

1. <dependency>
2. <groupId>io.grpc</groupId>
3. <artifactId>grpc-netty-shaded</artifactId>
4. <version>${grpc.version}</version>
5. </dependency>

七、源码验证解析

客户端

1、客户端序列化，可以查看MyRequest

 2、在客户端调用SimpleGrpc.SimpleBlockingStub.oneToOne方法时，已经将name序列化传输了

3、再往下可以看到客户端ClientCalls中，采用的是异步的方式进行发送二进制数据，等结束执行后再进行判断是否执行结束，

 waitAndDrain()即为等待，直到有一个Runnable，然后执行它和所有在它之后排队的Runnables。一次只能由一个线程调用。poll()方法用于从队列中取出并返回头部的元素，如果队列为空，则返回null。之后又将当前线程赋给了waiter，

 用的是线程池，在服务端断点的情况下，后续请求会进入等待队列。

服务端 

待更新。。。。。。

SpringBoot整合grpc_springboot grpc-CSDN博客

70.1 为应用添加Servlet，Filter或Listener · Spring Boot参考指南 · 看云