乐趣区

关于云计算:java版gRPC实战之二服务发布和调用

欢送拜访我的 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;

@Slf4j
public 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;

@SpringBootApplication
public 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;

@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 中有几处须要留神:
  • 是应用 <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: 8080
spring:
  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;

@SpringBootApplication
public 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;

@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 类有几处要留神的中央:
  • 用 <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;

@RestController
public 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

退出移动版