java 版 gRPC 实战之二：服务发布和调用

作者：程序员欣宸

2022 年 3 月 30 日
本文字数：5099 字
阅读完需：约 17 分钟

欢迎访问我的 GitHub

这里分类和汇总了欣宸的全部原创(含配套源码)：https://github.com/zq2599/blog_demos

### 本篇概览

- 本文是《java 版 gRPC 实战》系列的第二篇，前文《用proto生成代码》将父工程、依赖库版本、helloworld.proto 对应的 java 代码都准备好了，今天的任务是实战 gRPC 服务的开发和调用，实现的效果如下图：

- 本篇的具体操作如下：

1. 开发名为 local-server 的 springboot 应用，提供 helloworld.proto 中定义的 gRPC 服务；

2. 开发名为 local-client 的 springboot 应用，调用 local-server 提供的 gRPP 服务；

3. 验证 gRPC 服务能不能正常调用；

源码下载

本篇实战中的完整源码可在 GitHub 下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)：

这个 git 项目中有多个文件夹，《java 版 gRPC 实战》系列的源码在 grpc-tutorials 文件夹下，如下图红框所示：
grpc-tutorials 文件夹下有多个目录，本篇文章对应的代码在 local-server 和 local-client 中，如下图红框：

开发 gRPC 服务端

首先要开发的是 gRPC 服务端，回顾前文中 helloworld.proto 中定义的服务和接口，如下所示，名为 Simple 的服务对外提供名为 SayHello 接口，这就是咱们接下来的任务，创建一个 springboot 应用，该应用以 gRPC 的方式提供 SayHello 接口给其他应用远程调用：

service Simple {    // 接口定义    rpc SayHello (HelloRequest) returns (HelloReply) {    }}

复制代码

基于 springboot 框架开发一个普通的 gRPC 服务端应用，一共需要五个步骤，如下图所示，接下来我们按照下图序号的顺序来开发：
首先是在父工程 grpc-turtorials 下面新建名为 local-server 的模块，其 build.gradle 内容如下：

// 使用springboot插件plugins {    id 'org.springframework.boot'}
dependencies {    implementation 'org.projectlombok:lombok'    implementation 'org.springframework.boot:spring-boot-starter'    // 作为gRPC服务提供方，需要用到此库    implementation 'net.devh:grpc-server-spring-boot-starter'    // 依赖自动生成源码的工程    implementation project(':grpc-lib')}

复制代码

这是个 springboot 应用，配置文件内容如下：

spring:  application:    name: local-server# gRPC有关的配置，这里只需要配置服务端口号grpc:  server:    port: 9898

复制代码

新建拦截类 LogGrpcInterceptor.java，每当 gRPC 请求到来后该类会先执行，这里是将方法名字在日志中打印出来，您可以对请求响应做更详细的处理：

package com.bolingcavalry.grpctutorials;
import io.grpc.Metadata;import io.grpc.ServerCall;import io.grpc.ServerCallHandler;import io.grpc.ServerInterceptor;import lombok.extern.slf4j.Slf4j;
@Slf4jpublic class LogGrpcInterceptor implements ServerInterceptor {    @Override    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> serverCall, Metadata metadata,                                                                 ServerCallHandler<ReqT, RespT> serverCallHandler) {        log.info(serverCall.getMethodDescriptor().getFullMethodName());        return serverCallHandler.startCall(serverCall, metadata);    }}

复制代码

为了让 LogGrpcInterceptor 可以在 gRPC 请求到来时被执行，需要做相应的配置，如下所示，在普通的 bean 的配置中添加注解即可：

package com.bolingcavalry.grpctutorials;
import io.grpc.ServerInterceptor;import net.devh.boot.grpc.server.interceptor.GrpcGlobalServerInterceptor;import org.springframework.context.annotation.Configuration;
@Configuration(proxyBeanMethods = false)public class GlobalInterceptorConfiguration {    @GrpcGlobalServerInterceptor    ServerInterceptor logServerInterceptor() {        return new LogGrpcInterceptor();    }}

复制代码

应用启动类很简单：

package com.bolingcavalry.grpctutorials;
import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplicationpublic class LocalServerApplication {    public static void main(String[] args) {        SpringApplication.run(LocalServerApplication.class, args);    }}

复制代码

接下来是最重要的 service 类，gRPC 服务在此处对外暴露出去，完整代码如下，有几处要注意的地方稍后提到：

package com.bolingcavalry.grpctutorials;
import com.bolingcavalry.grpctutorials.lib.HelloReply;import com.bolingcavalry.grpctutorials.lib.SimpleGrpc;import net.devh.boot.grpc.server.service.GrpcService;import java.util.Date;
@GrpcServicepublic class GrpcServerService extends SimpleGrpc.SimpleImplBase {
    @Override    public void sayHello(com.bolingcavalry.grpctutorials.lib.HelloRequest request,                         io.grpc.stub.StreamObserver<com.bolingcavalry.grpctutorials.lib.HelloReply> responseObserver) {        HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + request.getName() + ", " + new Date()).build();        responseObserver.onNext(reply);        responseObserver.onCompleted();    }}

复制代码

上述 GrpcServerService.java 中有几处需要注意：

是使用 @GrpcService 注解，再继承 SimpleImplBase，这样就可以借助 grpc-server-spring-boot-starter 库将 sayHello 暴露为 gRPC 服务；
SimpleImplBase 是前文中根据 proto 自动生成的 java 代码，在 grpc-lib 模块中；
sayHello 方法中处理完毕业务逻辑后，调用 HelloReply.onNext 方法填入返回内容；
调用 HelloReply.onCompleted 方法表示本次 gRPC 服务完成；

至此，gRPC 服务端编码就完成了，咱们接着开始客户端开发；

调用 gRPC

在父工程 grpc-turtorials 下面新建名为 local-client 的模块，其 build.gradle 内容如下，注意要使用 spingboot 插件、依赖 grpc-client-spring-boot-starter 库：

plugins {    id 'org.springframework.boot'}
dependencies {    implementation 'org.projectlombok:lombok'    implementation 'org.springframework.boot:spring-boot-starter'    implementation 'org.springframework.boot:spring-boot-starter-web'    implementation 'net.devh:grpc-client-spring-boot-starter'    implementation project(':grpc-lib')}

复制代码

应用配置文件 grpc-tutorials/local-client/src/main/resources/application.yml，注意 address 的值就是 gRPC 服务端的信息，我这里 local-server 和 local-client 在同一台电脑上运行，请您根据自己情况来设置：

server:  port: 8080spring:  application:    name: local-grpc-client
grpc:  client:    # gRPC配置的名字，GrpcClient注解会用到    local-grpc-server:      # gRPC服务端地址      address: 'static://127.0.0.1:9898'      enableKeepAlive: true      keepAliveWithoutCalls: true      negotiationType: plaintext

复制代码

-接下来要创建下图展示的类，按序号顺序创建：

首先是拦截类 LogGrpcInterceptor，与服务端的拦截类差不多，不过实现的接口不同：

package com.bolingcavalry.grpctutorials;
import io.grpc.*;import org.slf4j.Logger;import org.slf4j.LoggerFactory;
public class LogGrpcInterceptor implements ClientInterceptor {
    private static final Logger log = LoggerFactory.getLogger(LogGrpcInterceptor.class);
    @Override    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method,            CallOptions callOptions, Channel next) {        log.info(method.getFullMethodName());        return next.newCall(method, callOptions);    }}

复制代码

为了让拦截类能够正常工作，即发起 gRPC 请求的时候被执行，需要新增一个配置类：

package com.bolingcavalry.grpctutorials;
import io.grpc.ClientInterceptor;import net.devh.boot.grpc.client.interceptor.GrpcGlobalClientInterceptor;import org.springframework.context.annotation.Configuration;import org.springframework.core.Ordered;import org.springframework.core.annotation.Order;
@Order(Ordered.LOWEST_PRECEDENCE)@Configuration(proxyBeanMethods = false)public class GlobalClientInterceptorConfiguration {
    @GrpcGlobalClientInterceptor    ClientInterceptor logClientInterceptor() {        return new LogGrpcInterceptor();    }}

复制代码

启动类：

package com.bolingcavalry.grpctutorials;
import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplicationpublic class LocalGrpcClientApplication {
    public static void main(String[] args) {        SpringApplication.run(LocalGrpcClientApplication.class, args);    }}

复制代码

接下来是最重要的服务类 GrpcClientService，有几处要注意的地方稍后会提到：

package com.bolingcavalry.grpctutorials;
import com.bolingcavalry.grpctutorials.lib.HelloReply;import com.bolingcavalry.grpctutorials.lib.HelloRequest;import com.bolingcavalry.grpctutorials.lib.SimpleGrpc;import io.grpc.StatusRuntimeException;import net.devh.boot.grpc.client.inject.GrpcClient;import org.springframework.stereotype.Service;
@Servicepublic class GrpcClientService {
    @GrpcClient("local-grpc-server")    private SimpleGrpc.SimpleBlockingStub simpleStub;
    public String sendMessage(final String name) {        try {            final HelloReply response = this.simpleStub.sayHello(HelloRequest.newBuilder().setName(name).build());            return response.getMessage();        } catch (final StatusRuntimeException e) {            return "FAILED with " + e.getStatus().getCode().name();        }    }}

复制代码

上述 GrpcClientService 类有几处要注意的地方：

用 @Service 将 GrpcClientService 注册为 spring 的普通 bean 实例；
用 @GrpcClient 修饰 SimpleBlockingStub，这样就可以通过 grpc-client-spring-boot-starter 库发起 gRPC 调用，被调用的服务端信息来自名为 local-grpc-server 的配置；
SimpleBlockingStub 来自前文中根据 helloworld.proto 生成的 java 代码；
SimpleBlockingStub.sayHello 方法会远程调用 local-server 应用的 gRPC 服务；

为了验证 gRPC 服务调用能否成功，再新增个 web 接口，接口内部会调用 GrpcClientService.sendMessage，这样咱们通过浏览器就能验证 gRPC 服务是否调用成功了：

package com.bolingcavalry.grpctutorials;
import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;
@RestControllerpublic class GrpcClientController {
    @Autowired    private GrpcClientService grpcClientService;
    @RequestMapping("/")    public String printMessage(@RequestParam(defaultValue = "will") String name) {        return grpcClientService.sendMessage(name);    }}

复制代码

编码完成，接下来将两个服务都启动，验证 gRPC 服务是否正常；

验证 gRPC 服务

local-server 和 local-client 都是普通的 springboot 应用，可以在 IDEA 中启动，点击下图红框位置，在弹出菜单中选择 Run 'LocalServerApplication'即可启动 local-server：
local-server 启动后，控制台会提示 gRPC server 已启动，正在监听 9898 端口，如下图：
local-client 后，在浏览器输入 http://localhost:8080/?name=Tom，可以看到响应的内容正是来自 local-server 的 GrpcServerService.java：