grpc-java springboot 同步异步调用 demo

曾经终败给现在 2021-09-21 21:10 794阅读 0赞

近期学习 grpc-java，从 demo 入手，进行学习

grpc 的基础知识暂不整理，后续有时间再整理一波，这一篇主要是记录一个简单的 grpc 使用 springboot 创建的 demo。

我整个 demo 分成三个 Project ：

  • grpc-springboot-demo-api：用于存放 proto 文件，生成Java 代码
  • grpc-springboot-demo-server：服务端代码
  • grpc-springboot-demo-consumer：客户端代码

demo-api（proto）

创建一个最简单的 proto 文件，请求跟相应都只包含一个 String 的对象。

  1. syntax = "proto3";
  3. option java_package = "grpc.springboot.demo.api";
  4. option java_outer_classname = "HelloWorldService";
  6. package helloworld;
  8. // 定义服务
  9. service HelloWorld {
  10.     rpc SayHello (HelloRequest) returns (HelloResponse) {}
  11. }
  13. // 定义请求体
  14. message HelloRequest {
  15.     string message = 1;
  16. }
  18. // 定义相应内容
  19. message HelloResponse {
  20.     string message = 1;
  21. }

文件创建好之后，需要进行编译，pom文件中需要引入相关插件：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.parallelline1996</groupId>
  8.     <artifactId>grpc-springboot-demo-api</artifactId>
  9.     <version>1.0.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>com.google.protobuf</groupId>
  14.             <artifactId>protobuf-java</artifactId>
  15.             <version>3.5.1</version>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>io.grpc</groupId>
  19.             <artifactId>grpc-all</artifactId>
  20.             <version>1.12.0</version>
  21.         </dependency>
  22.     </dependencies>
  24.     <build>
  25.         <extensions>
  26.             <extension>
  27.                 <groupId>kr.motd.maven</groupId>
  28.                 <artifactId>os-maven-plugin</artifactId>
  29.                 <version>1.4.1.Final</version>
  30.             </extension>
  31.         </extensions>
  32.         <plugins>
  33.             <plugin>
  34.                 <groupId>org.xolstice.maven.plugins</groupId>
  35.                 <artifactId>protobuf-maven-plugin</artifactId>
  36.                 <version>0.5.0</version>
  37.                 <configuration>
  38.                     <protocArtifact>com.google.protobuf:protoc:3.0.0:exe:${os.detected.classifier}</protocArtifact>
  39.                     <pluginId>grpc-java</pluginId>
  40.                     <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.0.0:exe:${os.detected.classifier}</pluginArtifact>
  41.                 </configuration>
  42.                 <executions>
  43.                     <execution>
  44.                         <goals>
  45.                             <goal>compile</goal>
  46.                             <goal>compile-custom</goal>
  47.                         </goals>
  48.                     </execution>
  49.                 </executions>
  50.             </plugin>
  51.             <plugin>
  52.                 <groupId>org.apache.maven.plugins</groupId>
  53.                 <artifactId>maven-compiler-plugin</artifactId>
  54.                 <configuration>
  55.                     <source>6</source>
  56.                     <target>6</target>
  57.                 </configuration>
  58.             </plugin>
  59.         </plugins>
  60.     </build>
  61. </project>

完成后，直接通过 maven 工具的 install 指令，推到本地仓库即可，构建时，便会自动生成我们需要的类。

在这里插入图片描述

demo-server

服务端项目的目录结构：

  • Starter：springboot 的启动类
  • GrpcServerConfiguration：grpc 服务端的启动类
  • HelloServerImpl：提供服务的实现类

在这里插入图片描述
首先 pom 文件，主要是导入 springboot 的启动的依赖，以及 grpc 的依赖，以及我们上面的 api 项目。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.parallelline1996</groupId>
  8.     <artifactId>grpc-springboot-demo-server</artifactId>
  9.     <version>1.0.0-SNAPSHOT</version>
  11.     <properties>
  12.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  13.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  14.     </properties>
  16.     <dependencies>
  17.         <dependency>
  18.             <groupId>com.parallelline1996</groupId>
  19.             <artifactId>grpc-springboot-demo-api</artifactId>
  20.             <version>1.0.0-SNAPSHOT</version>
  21.         </dependency>
  22.         <!-- spring boot -->
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-web</artifactId>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>org.springframework.boot</groupId>
  29.             <artifactId>spring-boot-starter-test</artifactId>
  30.             <scope>test</scope>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>org.apache.httpcomponents</groupId>
  34.             <artifactId>httpclient</artifactId>
  35.             <version>4.5.5</version>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>org.springframework.boot</groupId>
  39.             <artifactId>spring-boot-starter-actuator</artifactId>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>io.grpc</groupId>
  43.             <artifactId>grpc-all</artifactId>
  44.             <version>1.28.1</version>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>com.google.guava</groupId>
  48.             <artifactId>guava</artifactId>
  49.             <version>27.0-jre</version>
  50.         </dependency>
  51.     </dependencies>
  53.     <dependencyManagement>
  54.         <dependencies>
  55.             <dependency>
  56.                 <groupId>org.springframework.boot</groupId>
  57.                 <artifactId>spring-boot-dependencies</artifactId>
  58.                 <version>1.5.21.RELEASE</version>
  59.                 <type>pom</type>
  60.                 <scope>import</scope>
  61.             </dependency>
  62.         </dependencies>
  63.     </dependencyManagement>
  64. </project>

Starter 启动类：

  1. @SpringBootApplication
  2. public class Starter implements CommandLineRunner { 
  4.     private GrpcServerConfiguration configuration;
  6.     public Starter(GrpcServerConfiguration configuration) { 
  7.         this.configuration = configuration;
  8.     }
  10.     // 启动 grpc 服务端
  11.     @Override
  12.     public void run(String... args) throws Exception { 
  13.         configuration.start();
  14.     }
  16.     // 启动 springboot 容器
  17.     public static void main(String[] args) { 
  18.         SpringApplication.run(Starter.class, args);
  19.     }
  20. }

GrpcServerConfiguration grpc 服务端启动类：
这里注意：如果不在创建 Server 指定线程池，则会使用 grpc-java 中提供的默认线程池响应从客户端发送的请求（后续关于 Server 的创建，会再写博客说明）。也可以直接指定线程池，只需调用 ServerBuilder.executor(executor)
即可。

  1. @Component
  2. public class GrpcServerConfiguration { 
  4.     private static final Logger logger = LoggerFactory.getLogger(GrpcServerConfiguration.class);
  6.     // Grpc 服务端提供的服务
  7.     @Autowired
  8.     private HelloServiceImpl service;
  10.     // Grpc 服务端的地址
  11.     @Value("${grpc.server.port}")
  12.     private int port;
  13.     private Server server;
  14.     private ThreadPoolExecutor executor;
  16.     @PostConstruct
  17.     public void init() { 
  18.         executor = new ThreadPoolExecutor(10, 10, 60,
  19.                 TimeUnit.MILLISECONDS, new SynchronousQueue<>());
  20.     }
  22.     public void start() throws IOException { 
  23.         // 构建服务端
  24.         logger.info("Starting gRPC on port {}.", port);
  26.         // 使用默认线程池
  27.         server = ServerBuilder.forPort(port).addService(service).build().start();
  29.         // 使用自定义线程池用于处理请求
  30. // server = ServerBuilder.forPort(port).addService(service).executor(executor).build().start();
  32.         logger.info("gRPC server started, listening on {}.", port);
  34.         // 添加服务端关闭的逻辑
  35.         Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() { 
  36.             @Override
  37.             public void run() { 
  38.                 logger.info("Shutting down gRPC server.");
  39.                 GrpcServerConfiguration.this.stop();
  40.                 logger.info("gRPC server shut down successfully.");
  41.             }
  42.         }));
  43.     }
  45.     private void stop() { 
  46.         if (server != null) { 
  47.             // 关闭服务端
  48.             server.shutdown();
  49.         }
  50.     }

HelloServiceImpl：业务逻辑的实现类，继承 demo-api 中申明的 HelloWorldGrpc.HelloWorldImplBase，重写 sayHello 方法即可。

  1. @Component
  2. public class HelloServiceImpl extends HelloWorldGrpc.HelloWorldImplBase { 
  4.     private static final Logger logger = LoggerFactory.getLogger(HelloServiceImpl.class);
  6.     @Override
  7.     public void sayHello(HelloWorldService.HelloRequest request,
  8.                          StreamObserver<HelloWorldService.HelloResponse> responseObserver) { 
  9.         String message = request.getMessage();
  10.         logger.info("Client Received message:{}", message);
  12.         // 创建结果，返回响应内容
  13.         String rsp = String.format("Hello, %s. This message have send to server", message);
  14.         HelloWorldService.HelloResponse response = HelloWorldService.HelloResponse
  15.                 .newBuilder()
  16.                 .setMessage(rsp)
  17.                 .build();
  18.         responseObserver.onNext(response);
  19.         responseObserver.onCompleted();
  20.     }

demo-consumer

客服端项目的目录结构：

  • Starter：springboot 的启动类
  • GrpcClient：客户端的启动类
  • HelloController：对外提供服务

在这里插入图片描述

pom 文件，主要是导入 springboot 的启动的依赖，以及 grpc 的依赖，同样也需要引入 api 项目的依赖。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.parallelline1996</groupId>
  8.     <artifactId>grpc-springboot-demo-consumer</artifactId>
  9.     <version>1.0.0-SNAPSHOT</version>
  11.     <properties>
  12.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  13.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  14.     </properties>
  16.     <dependencies>
  17.         <dependency>
  18.             <groupId>com.parallelline1996</groupId>
  19.             <artifactId>grpc-springboot-demo-api</artifactId>
  20.             <version>1.0.0-SNAPSHOT</version>
  21.         </dependency>
  22.         <!-- spring boot -->
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-web</artifactId>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>org.springframework.boot</groupId>
  29.             <artifactId>spring-boot-starter-test</artifactId>
  30.             <scope>test</scope>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>org.apache.httpcomponents</groupId>
  34.             <artifactId>httpclient</artifactId>
  35.             <version>4.5.5</version>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>org.springframework.boot</groupId>
  39.             <artifactId>spring-boot-starter-actuator</artifactId>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>io.grpc</groupId>
  43.             <artifactId>grpc-all</artifactId>
  44.             <version>1.28.1</version>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>com.google.guava</groupId>
  48.             <artifactId>guava</artifactId>
  49.             <version>27.0-jre</version>
  50.         </dependency>
  51.     </dependencies>
  53.     <dependencyManagement>
  54.         <dependencies>
  55.             <dependency>
  56.                 <groupId>org.springframework.boot</groupId>
  57.                 <artifactId>spring-boot-dependencies</artifactId>
  58.                 <version>1.5.21.RELEASE</version>
  59.                 <type>pom</type>
  60.                 <scope>import</scope>
  61.             </dependency>
  62.         </dependencies>
  63.     </dependencyManagement>
  64. </project>

Starter，启动类，与服务端服务启动类无差异。

  1. @SpringBootApplication
  2. public class Starter implements CommandLineRunner { 
  4.     private GrpcClient configuration;
  6.     public Starter(GrpcClient configuration) { 
  7.         this.configuration = configuration;
  8.     }
  10.     // 启动 grpc 客户端
  11.     @Override
  12.     public void run(String... args) { 
  13.         configuration.start();
  14.     }
  16.     // 启动 springboot 容器
  17.     public static void main(String[] args) { 
  18.         SpringApplication.run(Starter.class, args);
  19.     }
  20. }

GrpcClient，gRPC 客户端，主要作用是监听 gRPC 服务端，开启通道。

  1. @Component
  2. public class GrpcClient { 
  4.     private static final Logger logger = LoggerFactory.getLogger(GrpcClient.class);
  6.     // Grpc 服务端的地址
  7.     @Value("${grpc.server.host}")
  8.     private String host;
  10.     // Grpc 服务端暴露的接口
  11.     @Value("${grpc.server.port}")
  12.     private int port;
  14.     private HelloWorldGrpc.HelloWorldBlockingStub stub;
  15.     private HelloWorldGrpc.HelloWorldFutureStub futureStub;
  17.     public void start() { 
  18.         // 开启channel
  19.         ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext().build();
  21.         // 通过 channel 获取服务端 blocking-stub
  22.         stub = HelloWorldGrpc.newBlockingStub(channel);
  23.         // 通过 channel 获取服务端 future-stub
  24.         futureStub = HelloWorldGrpc.newFutureStub(channel);
  26.         logger.info("gRPC client start, server address: host:{}, port:{}", host, port);
  27.     }
  29.     public HelloWorldGrpc.HelloWorldBlockingStub getStub() { 
  30.         return this.stub;
  31.     }
  33.     public HelloWorldGrpc.HelloWorldFutureStub getFutureStub() { 
  34.         return this.futureStub;
  35.     }
  36. }

gRPC 的客户端支持三种调用方式：

  • 同步调用
  • 基于 Future 的异步调用
  • 基于回调的异步调用

下面的代码分别对应三种调用方式：

  1. @RestController
  2. public class HelloController { 
  4.     private static final Logger logger = LoggerFactory.getLogger(HelloController.class);
  6.     @Autowired
  7.     GrpcClient configuration;
  9.     /** * 同步调用，阻塞 */
  10.     @GetMapping("/hello")
  11.     public String hello(@RequestParam(name = "name", defaultValue = "test", required = false) String name) { 
  12.         logger.info("Server received request.name={}", name);
  13.         // 构建一个请求
  14.         HelloWorldService.HelloRequest request = HelloWorldService.HelloRequest
  15.                 .newBuilder()
  16.                 .setMessage(name)
  17.                 .build();
  19.         // 使用stub发送请求至服务端
  20.         try { 
  21.             // 这里获取了一个 blocking-stub
  22.             HelloWorldGrpc.HelloWorldBlockingStub stub = configuration.getStub();
  23.             // 同步发送，将阻塞等待请求结果
  24.             HelloWorldService.HelloResponse response = stub.sayHello(request);
  25.             logger.info("Server response received: [{}]", response.toString());
  26.             return response.getMessage();
  27.         } catch (StatusRuntimeException e) { 
  28.             logger.info(" Error Received - Error code : {}", e.getStatus().getCode());
  29.         }
  30.         return "error";
  31.     }
  33.     /** * 基于 Future 的异步调用 */
  34.     @GetMapping("/hello-async-future")
  35.     public String helloAsyncFuture(@RequestParam(name = "name", defaultValue = "test", required = false) String name) { 
  36.         logger.info("Server received request.name={}", name);
  37.         // 构建一个请求
  38.         HelloWorldService.HelloRequest request = HelloWorldService.HelloRequest
  39.                 .newBuilder()
  40.                 .setMessage(name)
  41.                 .build();
  43.         // 使用stub发送请求至服务端
  44.         try { 
  45.             // 获取 future-stub 对象，调用请求后，将获取 future
  46.             ListenableFuture<HelloWorldService.HelloResponse> listenableFuture = configuration.getFutureStub().sayHello(request);
  47.             // 通过 future 对象的 get 请求获取结果
  48.             // 由于在同一线程中调用，并没有实现真正的异步，仍为同步阻塞
  49.             HelloWorldService.HelloResponse response = listenableFuture.get();
  50.             logger.info("Server response received: [{}]", response.toString());
  51.             return response.getMessage();
  52.         } catch (StatusRuntimeException e) { 
  53.             logger.info(" Error Received - Error code : {}", e.getStatus().getCode());
  54.         } catch (Exception e) { 
  55.             logger.error("error ", e);
  56.         }
  57.         return "error";
  58.     }
  60.     /** * 基于回调的异步调用 */
  61.     @GetMapping("/hello-async-callback")
  62.     public String helloAsyncCallback(@RequestParam(name = "name", defaultValue = "test", required = false) String name) { 
  63.         logger.info("Server received request.name={}", name);
  64.         // 构建一个请求
  65.         HelloWorldService.HelloRequest request = HelloWorldService.HelloRequest
  66.                 .newBuilder()
  67.                 .setMessage(name)
  68.                 .build();
  70.         // 使用stub发送请求至服务端
  71.         try { 
  72.             HelloWorldGrpc.HelloWorldFutureStub futureStub = configuration.getFutureStub();
  73.             ListenableFuture<HelloWorldService.HelloResponse> listenableFuture = futureStub.sayHello(request);
  75.             // 通过设备监听器，同时指定回调线程池的方式进行
  76.             listenableFuture.addListener(() -> { 
  77.                 try { 
  78.                     HelloWorldService.HelloResponse response = listenableFuture.get();
  79.                     logger.info("Server response received: [{}]", response.toString());
  80.                 } catch (Exception e) { 
  81.                     e.printStackTrace();
  82.                 }
  83.             }, new ThreadPoolExecutor(1, 1, 60,
  84.                     TimeUnit.MILLISECONDS, new SynchronousQueue<>()));
  86.             return "async";
  87.         } catch (StatusRuntimeException e) { 
  88.             logger.info(" Error Received - Error code : {}", e.getStatus().getCode());
  89.         } catch (Exception e) { 
  90.             logger.error("error ", e);
  91.         }
  92.         return "error";
  93.     }
  94. }

完整的代码连接：https://github.com/Parallelline1996/Daily-Learning/tree/master/gRPC/code-repository/grpc-springboot-demo

发表评论

表情：
评论列表 （有 0 条评论，794人围观）

还没有评论，来说两句吧...

相关阅读

    相关 同步调用和异步调用

    同步调用： 调用者等待被调用者返回结果（执行完）才执行下一步 优点： 代码简单 缺点： 若被调用者执行的是耗时操作，会产生阻塞 异步调用： 调用者不用等待

    系统管理员系统管理员/ 0 赞/ 133 阅读

    相关 SpringBoot异步调用

    除了异步请求，一般上我们用的比较多的应该是异步调用。通常在开发过程中，会遇到一个方法是和实际业务无关的，没有紧密性的。比如记录日志信息等业务。这个时候正常就是启一个新线程去做一

    Dear 丶Dear 丶/ 0 赞/ 532 阅读

    相关 Springboot 异步调用

    当我们业务中需要执行一个比较耗时的任务并且不影响主题程序的运行,那就需要异步了 首先,配置springboot框架整体的线程池: package pers.zc.a

    墨蓝墨蓝/ 0 赞/ 712 阅读