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)：

名稱	連結	備註
專案主頁	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中有幾處需要注意：

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 = "will") String name) {
        return grpcClientService.sendMessage(name);
    }
}

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

驗證gRPC服務

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

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

1. local-client後，在瀏覽器輸入http://localhost:8080/?name=Tom，可以看到響應的內容正是來自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