java版gRPC实战之二（服务发布和调用） _java版

少年意气强不羁，虎胁插翼白日飞。这篇文章主要讲述java版gRPC实战之二：服务发布和调用相关的知识，希望能为你提供帮助。
欢迎访问我的GitHub
本篇概览

本文是《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)：

名称	链接	备注
项目主页	https://github.com/zq2599/blog_demos	该项目在GitHub上的主页
git仓库地址(https)	https://github.com/zq2599/blog_demos.git	该项目源码的仓库地址，https协议
git仓库地址(ssh)	git@github.com:zq2599/blog_demos.git	该项目源码的仓库地址，ssh协议

这个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应用，配置文件内容如下： ```yaml 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;
@Slf4j
public class LogGrpcInterceptor implements ServerInterceptor @Override
br/>@Override
ServerCallHandler< ReqT, RespT> serverCallHandler)
log.info(serverCall.getMethodDescriptor().getFullMethodName());
return serverCallHandler.startCall(serverCall, metadata);

- 为了让LogGrpcInterceptor可以在gRPC请求到来时被执行，需要做相应的配置，如下所示，在普通的bean的配置中添加注解即可： ```java 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;
@SpringBootApplication
public class LocalServerApplication
public static void main(String[] args)
SpringApplication.run(LocalServerApplication.class, args);

- 接下来是最重要的service类，gRPC服务在此处对外暴露出去，完整代码如下，有几处要注意的地方稍后提到： ```java 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; @GrpcService public 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中有几处需要注意：
1. 使用@GrpcService注解，再继承SimpleImplBase，这样就可以借助grpc-server-spring-boot-starter库将sayHello暴露为gRPC服务；
2. SimpleImplBase是前文中根据proto自动生成的java代码，在grpc-lib模块中；
3. sayHello方法中处理完毕业务逻辑后，调用HelloReply.onNext方法填入返回内容；
4. 调用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在同一台电脑上运行，请您根据自己情况来设置： ```yml server: port: 8080 spring: application: name: local-grpc-clientgrpc: client: # gRPC配置的名字，GrpcClient注解会用到 local-grpc-server: # gRPC服务端地址 address: static://127.0.0.1:9898 enableKeepAlive: true keepAliveWithoutCalls: true negotiationType: plaintext

【java版gRPC实战之二（服务发布和调用）】-接下来要创建下图展示的类，按序号顺序创建：

文章图片

首先是拦截类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请求的时候被执行，需要新增一个配置类： ```java 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;
@SpringBootApplication
public class LocalGrpcClientApplication

public static void main(String[] args) SpringApplication.run(LocalGrpcClientApplication.class, args);

- 接下来是最重要的服务类GrpcClientService，有几处要注意的地方稍后会提到： ```java 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; @Service public 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类有几处要注意的地方：
1. 用@Service将GrpcClientService注册为spring的普通bean实例；
2. 用@GrpcClient修饰SimpleBlockingStub，这样就可以通过grpc-client-spring-boot-starter库发起gRPC调用，被调用的服务端信息来自名为==local-grpc-server==的配置；
3. SimpleBlockingStub来自前文中根据helloworld.proto生成的java代码；
4. 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;
@RestController
public class GrpcClientController

@Autowired private GrpcClientService grpcClientService; @RequestMapping("/") public String printMessage(@RequestParam(defaultValue = "https://www.songbingjia.com/android/will") String name) return grpcClientService.sendMessage(name);

- 编码完成，接下来将两个服务都启动，验证gRPC服务是否正常； ### 验证gRPC服务 1. ==local-server==和==local-client==都是普通的springboot应用，可以在IDEA中启动，点击下图红框位置，在弹出菜单中选择Run LocalServerApplication即可启动local-server： ![在这里插入图片描述](https://s4.51cto.com/images/blog/202112/23225528_61c48de0d718753774.png?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=) 2. local-server启动后，控制台会提示gRPC server已启动，正在监听9898端口，如下图： ![在这里插入图片描述](https://s4.51cto.com/images/blog/202112/23225529_61c48de1350eb24167.png?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=) 3. local-client后，在浏览器输入==http://localhost:8080/?name=Tom==，可以看到响应的内容正是来自local-server的GrpcServerService.java： ![在这里插入图片描述](https://s4.51cto.com/images/blog/202112/23225529_61c48de13479d70410.png?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)4. 从web端到gRPC服务端的关键节点信息如下图： ![在这里插入图片描述](https://s4.51cto.com/images/blog/202112/23225530_61c48de23471375437.png?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=) - 可以看到local-server的拦截日志： ![在这里插入图片描述](https://s4.51cto.com/images/blog/202112/23225529_61c48de147b0924881.png?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=) - 还有local-client的拦截日志： ![在这里插入图片描述](https://s4.51cto.com/images/blog/202112/23225529_61c48de16a5d610430.png?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)- 至此，最简单的java版gRPC服务发布和调用验证通过，本篇的任务也就完成了，接下来的文章，咱们会继续深入学习java版gRPC的相关技术；### 欢迎关注公众号：程序员欣宸 > 微信搜索「程序员欣宸」，我是欣宸，期待与您一同畅游Java世界...