Java 启动rpc server_gRPC创建Java RPC服务

1.说明

本文介绍使用gRPC创建Java版本的RPC服务，

包括通过.proto文件生成Java代码的方法，

以及服务端和客户端代码使用示例。

2.创建生成代码工程

创建Maven工程，grpc-compile。

2.1.修改pom.xml

引入生成代码需要的jar包依赖，

以及构建依赖配置：

io.grpc

grpc-protobuf

1.32.1

io.grpc

grpc-stub

1.32.1

kr.motd.maven

os-maven-plugin

1.6.2

org.xolstice.maven.plugins

protobuf-maven-plugin

0.6.1

com.google.protobuf:protoc:3.12.0:exe:${os.detected.classifier}

grpc-java

io.grpc:protoc-gen-grpc-java:1.32.1:exe:${os.detected.classifier}

compile

compile-custom

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目录下生成代码:

主要关注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包:

io.grpc

grpc-netty-shaded

1.32.1

io.grpc

grpc-protobuf

1.32.1

io.grpc

grpc-stub

1.32.1

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;

/**

*

* greeting服务实现类

*

*/

public class GreeterImpl extends GreeterGrpc.GreeterImplBase {

@Override

public void sayHello(HelloRequest req, StreamObserver responseObserver) {

HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();

responseObserver.onNext(reply);

responseObserver.onCompleted();

}

@Override

public void sayHelloAgain(HelloRequest req, StreamObserver 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 {

// ManagedChannel使用像线程和TCP连接这样的资源。

// 为了防止泄漏这些资源，通道应该在不再使用时关闭。

channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);

}

}

}

4.4.客户端启动

通过执行GRPCClient的main方法，

就能启动客户端了，

通过gRPC调用服务端成功后打印日志：

Will try to greet world ...

Greeting: Hello world

5.参考文档