一. 摘要

  1. 此篇文章将用实例介绍grpc四种服务类型中的最普通的单项 rpc。

二. 实践

整体项目如下：
image.png
其中cloud-grpc-java为maven项目，cloud-grpc-protos为定义接口项目。

1.通过protobuf定义接口和数据类型

在cloud-grpc-protos文件夹下创建hello.proto,内容如下：

  1. syntax = "proto3";
  3. option go_package = "pbfs/hello";
  4. option java_multiple_files = true;
  5. option java_package = "com.cloud.grpc.hello";
  6. option java_outer_classname = "HelloProto";
  7. option objc_class_prefix = "HL";
  9. package hello;
  11. service Hello {
  12.   rpc SayHello (HelloRequest) returns (HelloResponse) {}
  13. }
  15. // The request message containing the user's name.
  16. message HelloRequest {
  17.   string name = 1;
  18. }
  20. // The response message containing the greetings
  21. message HelloResponse {
  22.   string message = 1;
  23. }

以上，一个 简单 RPC ， 客户端使用存根发送请求到服务器并等待响应返回，就像平常的函数调用一样。定义一个SayHello rpc服务，入参：HelloRequest，返参：HelloResponse

2.maven 配置

创建一个如上图（cloud-grpc-java)的maven项目,pom.xml加入grpc开发相关配置，如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  6.     <groupId>com.cloud.grpc</groupId>
  7.     <artifactId>java</artifactId>
  8.     <version>1.0.0.0</version>
  9.     <name>java</name>
  10.     <description>Demo project for grpc for java</description>
  12.     <properties>
  13.         <java.version>11</java.version>
  14.         <grpc.version>1.29.0</grpc.version>
  15.         <protobuf.version>3.11.0</protobuf.version>
  16.     </properties>
  18.     <dependencies>
  20.         <dependency>
  21.             <groupId>io.grpc</groupId>
  22.             <artifactId>grpc-netty-shaded</artifactId>
  23.             <version>${grpc.version}</version>
  24.         </dependency>
  26.         <dependency>
  27.             <groupId>io.grpc</groupId>
  28.             <artifactId>grpc-protobuf</artifactId>
  29.             <version>${grpc.version}</version>
  30.         </dependency>
  32.         <dependency>
  33.             <groupId>io.grpc</groupId>
  34.             <artifactId>grpc-stub</artifactId>
  35.             <version>${grpc.version}</version>
  36.         </dependency>
  38.         <dependency> <!-- necessary for Java 9+ -->
  39.             <groupId>org.apache.tomcat</groupId>
  40.             <artifactId>annotations-api</artifactId>
  41.             <version>6.0.53</version>
  42.             <scope>provided</scope>
  43.         </dependency>
  45.     </dependencies>
  47.     <build>
  49.         <extensions>
  50.             <extension>
  51.                 <groupId>kr.motd.maven</groupId>
  52.                 <artifactId>os-maven-plugin</artifactId>
  53.                 <version>1.5.0.Final</version>
  54.             </extension>
  55.         </extensions>
  57.         <plugins>
  58.             <plugin>
  59.                 <groupId>org.xolstice.maven.plugins</groupId>
  60.                 <artifactId>protobuf-maven-plugin</artifactId>
  61.                 <version>0.5.1</version>
  63.                 <configuration>
  64.                     <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
  65.                    <pluginId>grpc-java</pluginId>
  66.                     <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
  67.                     <protoSourceRoot>../cloud-grpc-protos</protoSourceRoot>
  68.                 </configuration>
  70.                 <executions>
  71.                     <execution>
  72.                         <goals>
  73.                             <goal>compile</goal>
  74.                             <goal>compile-custom</goal>
  75.                         </goals>
  76.                     </execution>
  77.                 </executions>
  78.             </plugin>
  79.         </plugins>
  80.     </build>
  82. </project>

说明： ../cloud-grpc-protos 红色标注部分需要根据pom.xml与上面创建proto所在路径相匹配，这样protobuf 插件才会根据此目录找到定义的proto文件生成相关代码。

3.生成grpc,protobuf相关类

  1. mvn protobuf:compile
  2. mvn protobuf:compile-custom

同步pom.xml,即可在target下生成如下源码：
image.png

4.编写服务端，并运行

编写HelloServer.java如下

  1. package com.cloud.grpc.java.standard.server;
  3. import com.cloud.grpc.hello.HelloGrpc;
  4. import com.cloud.grpc.hello.HelloRequest;
  5. import com.cloud.grpc.hello.HelloResponse;
  6. import io.grpc.Server;
  7. import io.grpc.ServerBuilder;
  8. import io.grpc.stub.StreamObserver;
  10. import java.io.IOException;
  11. import java.util.concurrent.TimeUnit;
  13. public class HelloServer {
  15.     private Server server;
  16.     private void start() throws IOException {
  17.         /* The port on which the server should run */
  18.         int port = 50051;
  19.         server = ServerBuilder.forPort(port)
  20.                 .addService(new HelloIml())  //这里可以添加多个模块
  21.                 .build()
  22.                 .start();
  23.         System.out.println("Server started, listening on " + port);
  24.         Runtime.getRuntime().addShutdownHook(new Thread() {
  25.             @Override
  26.             public void run() {
  27.                 // Use stderr here since the logger may have been reset by its JVM shutdown hook.
  28.                 System.err.println("*** shutting down gRPC server since JVM is shutting down");
  29.                 try {
  30.                     HelloServer.this.stop();
  31.                 } catch (InterruptedException e) {
  32.                     e.printStackTrace(System.err);
  33.                 }
  34.                 System.err.println("*** server shut down");
  35.             }
  36.         });
  37.     }
  39.     private void stop() throws InterruptedException {
  40.         if (server != null) {
  41.             server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
  42.         }
  43.     }
  45.     private void blockUntilShutdown() throws InterruptedException {
  46.         if (server != null) {
  47.             server.awaitTermination();
  48.         }
  49.     }
  51.     public static void main(String[] args) throws IOException, InterruptedException {
  52.         final HelloServer server = new HelloServer();
  53.         server.start();
  54.         server.blockUntilShutdown();
  55.     }
  57.     private static class HelloIml extends HelloGrpc.HelloImplBase{
  58.         @Override
  59.         public void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver) {
  60.            // super.sayHello(request, responseObserver);
  61.             HelloResponse helloResponse=HelloResponse.newBuilder().setMessage("Hello "+request.getName()+", I'm Java grpc Server").build();
  62.             responseObserver.onNext(helloResponse);
  63.             responseObserver.onCompleted();
  64.         }
  65.     }
  66. }

通过main函数启动：结果如下：
image.png

5.编写，运行客户端

编写HelloClient.java,如下：

  1. package com.cloud.grpc.java.standard.client;
  3. import com.cloud.grpc.hello.HelloGrpc;
  4. import com.cloud.grpc.hello.HelloRequest;
  5. import com.cloud.grpc.hello.HelloResponse;
  6. import io.grpc.ManagedChannel;
  7. import io.grpc.ManagedChannelBuilder;
  9. import java.util.concurrent.TimeUnit;
  11. public class HelloClient {
  13.     //远程连接管理器,管理连接的生命周期
  14.     private final ManagedChannel channel;
  15.     private final HelloGrpc.HelloBlockingStub blockingStub;
  17.     public HelloClient(String host, int port) {
  18.         //初始化连接
  19.         channel = ManagedChannelBuilder.forAddress(host, port)
  20.                 .usePlaintext()
  21.                 .build();
  22.         //初始化远程服务Stub
  23.         blockingStub = HelloGrpc.newBlockingStub(channel);
  24.     }
  27.     public void shutdown() throws InterruptedException {
  28.         //关闭连接
  29.         channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
  30.     }
  32.     public String sayHello(String name) {
  33.         //构造服务调用参数对象
  34.         HelloRequest request = HelloRequest.newBuilder().setName(name).build();
  35.         //调用远程服务方法
  36.         HelloResponse response = blockingStub.sayHello(request);
  37.         //返回值
  38.         return response.getMessage();
  39.     }
  42.     public static void main(String[] args) throws InterruptedException {
  43.         HelloClient client = new HelloClient("127.0.0.1", 50051);
  44.         //服务调用
  45.         String content = client.sayHello("Java client");
  46.         //打印调用结果
  47.         System.out.println(content);
  48.         //关闭连接
  49.         client.shutdown();
  50.     }
  52. }

执行main函数，结果如下：
image.png
可见已从服务端获取响应。