java版gRPC實戰之二：服務釋出和呼叫

歡迎訪問我的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)	[email protected]: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);

    }

}