欢送拜访我的GitHub

https://github.com/zq2599/blog_demos

内容：所有原创文章分类汇总及配套源码，波及Java、Docker、Kubernetes、DevOPS等；

本篇概览

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

  • 本篇的具体操作如下：
  • 开发名为<font color="blue">local-server</font>的springboot利用，提供helloworld.proto中定义的gRPC服务；
  • 开发名为<font color="blue">local-client</font>的springboot利用，调用<font color="blue">local-server</font>提供的gRPP服务；
  • 验证gRPC服务能不能失常调用；

源码下载

  • 本篇实战中的残缺源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blo...：
名称链接备注
我的项目主页https://github.com/zq2599/blo...该我的项目在GitHub上的主页
git仓库地址(https)https://github.com/zq2599/blo...该我的项目源码的仓库地址，https协定
git仓库地址(ssh)git@github.com:zq2599/blog_demos.git该我的项目源码的仓库地址，ssh协定
  • 这个git我的项目中有多个文件夹，《java版gRPC实战》系列的源码在<font color="blue">grpc-tutorials</font>文件夹下，如下图红框所示：

  • <font color="blue">grpc-tutorials</font>文件夹下有多个目录，本篇文章对应的代码在<font color="blue">local-server</font>和<font color="blue">local-client</font>中，如下图红框：

开发gRPC服务端

  • 首先要开发的是gRPC服务端，回顾前文中helloworld.proto中定义的服务和接口，如下所示，名为Simple的服务对外提供名为SayHello接口，这就是咱们接下来的工作，创立一个springboot利用，该利用以gRPC的形式提供SayHello接口给其余利用近程调用：
service Simple {    // 接口定义    rpc SayHello (HelloRequest) returns (HelloReply) {    }}
  • 基于springboot框架开发一个一般的gRPC服务端利用，一共须要五个步骤，如下图所示，接下来咱们依照下图序号的程序来开发：

  • 首先是在父工程<font color="blue">grpc-turtorials</font>上面新建名为<font color="">local-server</font>的模块，其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
  • 新建拦挡类<font color="blue">LogGrpcInterceptor.java</font>，每当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中有几处须要留神：
  • 是应用<font color="blue">@GrpcService</font>注解，再继承SimpleImplBase，这样就能够借助grpc-server-spring-boot-starter库将sayHello裸露为gRPC服务；
  • SimpleImplBase是前文中依据proto主动生成的java代码，在grpc-lib模块中；
  • sayHello办法中处理完毕业务逻辑后，调用HelloReply.onNext办法填入返回内容；
  • 调用HelloReply.onCompleted办法示意本次gRPC服务实现；
  • 至此，gRPC服务端编码就实现了，咱们接着开始客户端开发；

调用gRPC

  • 在父工程<font color="blue">grpc-turtorials</font>上面新建名为<font color="">local-client</font>的模块，其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-clientgrpc:  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类有几处要留神的中央：
  • 用<font color="blue">@Service</font>将GrpcClientService注册为spring的一般bean实例；
  • 用<font color="blue">@GrpcClient</font>润饰SimpleBlockingStub，这样就能够通过grpc-client-spring-boot-starter库发动gRPC调用，被调用的服务端信息来自名为<font color="red">local-grpc-server</font>的配置；
  • 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服务

  1. <font color="blue">local-server</font>和<font color="blue">local-client</font>都是一般的springboot利用，能够在IDEA中启动，点击下图红框地位，在弹出菜单中选择<font color="red">Run 'LocalServerApplication'</font>即可启动local-server：

  1. local-server启动后，控制台会提醒gRPC server已启动，正在监听9898端口，如下图：

  1. local-client后，在浏览器输出<font color="blue">http://localhost:8080/?name=Tom</font>，能够看到响应的内容正是来自local-server的GrpcServerService.java：

  1. 从web端到gRPC服务端的要害节点信息如下图：

  • 能够看到local-server的拦挡日志：

  • 还有local-client的拦挡日志：

  • 至此，最简略的java版gRPC服务公布和调用验证通过，本篇的工作也就实现了，接下来的文章，咱们会持续深刻学习java版gRPC的相干技术；

你不孤独，欣宸原创一路相伴

  1. Java系列
  2. Spring系列
  3. Docker系列
  4. kubernetes系列
  5. 数据库+中间件系列
  6. DevOps系列

欢送关注公众号：程序员欣宸

微信搜寻「程序员欣宸」，我是欣宸，期待与您一起畅游Java世界...
https://github.com/zq2599/blog_demos