java版gRPC實戰之二：服務發布和呼叫

歡迎訪問我的GitHub

https://github.com/zq2599/blog_demos

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

本篇概覽

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

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

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在同一臺電腦上運行，請您根據自己情況來設定：

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類有幾處要注意的地方：

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.cnblogs.com/bolingcavalry/archive/2021/09/14/will") String name) {
        return grpcClientService.sendMessage(name);
    }
}

• 編碼完成，接下來將兩個服務都啟動，驗證gRPC服務是否正常；

驗證gRPC服務

1. local-server和local-client都是普通的springboot應用，可以在IDEA中啟動，點擊下圖紅框位置，在彈出選單中選擇Run 'LocalServerApplication'即可啟動local-server：

2. local-server啟動后，控制臺會提示gRPC server已啟動，正在監聽9898埠，如下圖：

3. local-client后，在瀏覽器輸入http://localhost:8080/?name=Tom，可以看到回應的內容正是來自local-server的GrpcServerService.java：

4. 從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

標籤：其他

上一篇：Python游戲開發，pygame模塊，Python實作乒乓球小游戲

下一篇：用好這個 IDEA 插件，寫代碼效率至少提升 5 倍！