gRPC创建Java RPC服务

时间:2023-02-05 10:03:29

1.说明

本文介绍使用gRPC创建Java版本的RPC服务,
包括通过.proto文件生成Java代码的方法,
以及服务端和客户端代码使用示例。

2.创建生成代码工程

创建Maven工程,grpc-compile。

2.1.修改pom.xml

引入生成代码需要的jar包依赖,
以及构建依赖配置:

<dependencies>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-protobuf</artifactId>
<version>1.32.1</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-stub</artifactId>
<version>1.32.1</version>
</dependency>
</dependencies>
<build>
<extensions>
<extension>
<groupId>kr.motd.maven</groupId>
<artifactId>os-maven-plugin</artifactId>
<version>1.6.2</version>
</extension>
</extensions>
<plugins>
<plugin>
<groupId>org.xolstice.maven.plugins</groupId>
<artifactId>protobuf-maven-plugin</artifactId>
<version>0.6.1</version>
<configuration>
<protocArtifact>com.google.protobuf:protoc:3.12.0:exe:${os.detected.classifier}</protocArtifact>
<pluginId>grpc-java</pluginId>
<pluginArtifact>io.grpc:protoc-gen-grpc-java:1.32.1:exe:${os.detected.classifier}</pluginArtifact>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>compile-custom</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>

2.2.创建.proto文件

在src\main下面新建proto目录,
在里面创建helloworld.proto文件:

// 显示声明使用proto3, 否则使用默认的proto2
syntax = "proto3"; // 生成类的包名
option java_package = "com.asiainfo.yuwen.grpc.helloworld";
// 生成类的文件名,否则默认生成的类名为proto文件名的驼峰命名
option java_outer_classname = "HelloWorldProto";
// 定义的所有消息、枚举和服务生成对应的多个类文件,而不是以内部类的形式出现
option java_multiple_files = false; // greeting服务定义
service Greeter {
// sayHello方法,格式为"方法名 请求参数 返回参数"
rpc SayHello (HelloRequest) returns (HelloReply) {}
// 另一个sayHello方法
rpc SayHelloAgain (HelloRequest) returns (HelloReply) {}
} // 方法请求,包含用户名
message HelloRequest {
string name = 1;
} // 方法响应,包含响应的消息
message HelloReply {
string message = 1;
}

2.3.生成Java代码

在grpc-compile下执行Maven编译命令:

mvn clean compile

会在target目录下生成代码:

gRPC创建Java RPC服务

主要关注generated-sources目录:
generated-sources\protobuf\grpc-java目录下生成了
com\asiainfo\yuwen\grpc\helloworld\GreeterGrpc.java;
generated-sources\protobuf\java目录下生成了
com\asiainfo\yuwen\grpc\helloworld\HelloWorldProto.java。

其中GreeterGrpc.java对应greeting服务定义,
如果有多个服务,会对应生成多个java类,
HelloWorldProto.java对应消息、枚举等对象的定义。
由于生成的代码内容太多了,这里就不贴出来了。

3.创建服务端工程

创建Maven工程,grpc-server。

3.1.修改pom.xml

引入使用gRPC需要依赖的jar包:

<dependencies>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-netty-shaded</artifactId>
<version>1.32.1</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-protobuf</artifactId>
<version>1.32.1</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-stub</artifactId>
<version>1.32.1</version>
</dependency>
</dependencies>

3.2.拷贝生成的代码

把上面生成的Java代码,
GreeterGrpc.java和HelloWorldProto.java,
拷贝到grpc-server的src/main/java目录下,
可以从com这一层目录开始拷贝,
这样就不用再手动创建包路径了。

3.3.创建greeting服务实现类

为了实现greeting服务定义的两个sayHello方法,
需要继承GreeterGrpc.GreeterImplBase接口,
创建实现类GreeterImpl.java:

package com.asiainfo.yuwen.grpc.helloworld.controller.impl;

import com.asiainfo.yuwen.grpc.helloworld.GreeterGrpc;
import com.asiainfo.yuwen.grpc.helloworld.HelloWorldProto.HelloReply;
import com.asiainfo.yuwen.grpc.helloworld.HelloWorldProto.HelloRequest; import io.grpc.stub.StreamObserver; /**
* <pre>
* greeting服务实现类
* </pre>
*/
public class GreeterImpl extends GreeterGrpc.GreeterImplBase { @Override
public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
responseObserver.onNext(reply);
responseObserver.onCompleted();
} @Override
public void sayHelloAgain(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
HelloReply reply = HelloReply.newBuilder().setMessage("Hello again " + req.getName()).build();
responseObserver.onNext(reply);
responseObserver.onCompleted();
}
}

3.4.创建服务端启动类

为了对外提供gRPC服务,
需要创建服务端启动类GRPCServer.java:

package com.asiainfo.yuwen.grpc.server;

import java.io.IOException;
import java.util.concurrent.TimeUnit; import com.asiainfo.yuwen.grpc.helloworld.controller.impl.GreeterImpl; import io.grpc.Server;
import io.grpc.ServerBuilder; /**
* gRPC服务启动类,启动时注册添加需要对外提供的服务类
*/
public class GRPCServer { private Server server; private void start() throws IOException {
// 服务运行端口
int port = 50051;
// 注册暴露对外提供的服务
server = ServerBuilder.forPort(port).addService(new GreeterImpl()).build().start();
System.out.println("Server started, listening on " + port); Runtime.getRuntime().addShutdownHook(new Thread() {
@Override
public void run() {
// 使用标准错误输出,因为日志记录器有可能在JVM关闭时被重置
System.err.println("*** shutting down gRPC server since JVM is shutting down");
try {
GRPCServer.this.stop();
} catch (InterruptedException e) {
e.printStackTrace(System.err);
}
System.err.println("*** server shut down");
}
});
} private void stop() throws InterruptedException {
if (server != null) {
server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
}
} /**
* 在主线程上等待终止,因为grpc库使用守护进程。
*/
private void blockUntilShutdown() throws InterruptedException {
if (server != null) {
server.awaitTermination();
}
} /**
* 启动服务Main方法
*/
public static void main(String[] args) throws IOException, InterruptedException {
final GRPCServer server = new GRPCServer();
server.start();
server.blockUntilShutdown();
}
}

3.5.服务端启动

通过执行GRPCServer的main方法,
就能启动服务了,
启动成功打印日志:

Server started, listening on 50051

4.创建服务端工程

创建Maven工程,grpc-client。

4.1.修改pom.xml

操作步骤和上面服务端相同。

4.2.拷贝生成的代码

操作步骤和上面服务端相同。
由于客户端和服务端都依赖了生成的代码,
以及依赖相同的jar包,
可以提取到common公共工程里面,
这样方便其他工程依赖和后续修改。

4.3.创建客户端调用类

创建一个简单的客户端,
用于测试greeting服务,
创建GRPCClient.java:

package com.asiainfo.yuwen.grpc.client;

import java.util.concurrent.TimeUnit;

import com.asiainfo.yuwen.grpc.helloworld.GreeterGrpc;
import com.asiainfo.yuwen.grpc.helloworld.HelloWorldProto.HelloReply;
import com.asiainfo.yuwen.grpc.helloworld.HelloWorldProto.HelloRequest; import io.grpc.Channel;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.StatusRuntimeException; /**
* 一个简单的客户端,测试greeting服务
*/
public class GRPCClient { private final GreeterGrpc.GreeterBlockingStub greeterBlocStub; /**
* 构造使用现有通道访问服务端的客户端
*/
public GRPCClient(Channel channel) {
// 'channel'在这里是Channel,而不是ManagedChannel,所有它负责关闭 // 向代码传递通道可以使代码更容易测试,也可以更容易地重用通道。
// 同时这里创建的是同步(阻塞)RPC服务。
greeterBlocStub = GreeterGrpc.newBlockingStub(channel);
} /** 向服务端发送请求 */
public void greet(String name) {
System.out.println("Will try to greet " + name + " ...");
HelloRequest request = HelloRequest.newBuilder().setName(name).build();
HelloReply response;
try {
response = greeterBlocStub.sayHello(request);
} catch (StatusRuntimeException e) {
System.out.println("WARNING, RPC failed: Status=" + e.getStatus());
return;
}
System.out.println("Greeting: " + response.getMessage());
} /**
* 客户端启动入口,可以支持填写2个参数,否则使用默认值。 第1个参数是用户名。 第2个参数是目标服务器,格式IP:Port。
*/
public static void main(String[] args) throws Exception {
String user = "world";
// 访问本机在50051端口上运行的服务
String target = "localhost:50051";
// 命令行用法帮助,允许将用户名和目标服务器作为命令行参数传入。
if (args.length > 0) {
if ("--help".equals(args[0])) {
System.err.println("Usage: [name [target]]");
System.err.println("");
System.err.println(" name The name you wish to be greeted by. Defaults to " + user);
System.err.println(" target The server to connect to. Defaults to " + target);
System.exit(1);
}
user = args[0];
}
if (args.length > 1) {
target = args[1];
} // 创建到服务器的通信通道,通道是线程安全的和可重用的。
// 通常在应用程序开始时创建通道,并重用直到应用程序关闭。
ManagedChannel channel = ManagedChannelBuilder.forTarget(target).usePlaintext().build();
try {
GRPCClient client = new GRPCClient(channel);
client.greet(user);
} finally {
// ManagedChannels使用像线程和TCP连接这样的资源。
// 为了防止泄漏这些资源,通道应该在不再使用时关闭。
channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
}
}
}

4.4.客户端启动

通过执行GRPCClient的main方法,
就能启动客户端了,
通过gRPC调用服务端成功后打印日志:

Will try to greet world ...
Greeting: Hello world

5.参考文档

GRPC的JAVA使用介绍
Grpc系列一 第一个hello world 例子