java版gRPC實戰之二：服務發布和調用

本文轉載自查看原文 2021-09-14 08:22 353

歡迎訪問我的GitHub

https://github.com/zq2599/blog_demos

內容：所有原創文章分類匯總及配套源碼，涉及Java、Docker、Kubernetes、DevOPS等；

本篇概覽

本文是《java版gRPC實戰》系列的第二篇，前文《用proto生成代碼》將父工程、依賴庫版本、helloworld.proto對應的java代碼都准備好了，今天的任務是實戰gRPC服務的開發和調用，實現的效果如下圖：

在這里插入圖片描述

本篇的具體操作如下：

開發名為local-server的springboot應用，提供helloworld.proto中定義的gRPC服務；
開發名為local-client的springboot應用，調用local-server提供的gRPP服務；
驗證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應用，配置文件內容如下：

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
    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中有幾處需要注意：

是使用@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: 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類有幾處要注意的地方：

用@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;

@RestController
public class GrpcClientController {

    @Autowired
    private GrpcClientService grpcClientService;

    @RequestMapping("/")
    public String printMessage(@RequestParam(defaultValue = "will") String name) {
        return grpcClientService.sendMessage(name);
    }
}