IDEA + Spring Boot + Gradle + gRPC入门笔记

什么是gRPC
gRPC 是Google发起的一个开源远程过程调用 系统。该系统基于HTTP/2 协议传输,使用Protocol Buffers 作为接口描述语言。 其他功能: 认证 双向流 流控制 过期 最常见的应用场景是: 微服务框架下,多种语言服务之间的高效交互。 将手机服务、浏览器连接至后台 产生高效的客户端库。

我们将使用以下框架 or 工具
IDEA 2021.1
Gradle 6.8.3
Spring Boot 2.3.10
gRPC 1.37.0
protobuf 3.15.2

1. 新建springboot项目

可以在 https://start.spring 生成springboot项目
image.png

2. 配置build.gradle

plugins {
    id 'org.springframework.boot' version '2.3.10.RELEASE'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'com.google.protobuf' version '0.8.15'
    id 'java'
    id 'idea'
}

group = 'com.ben'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

configurations {
    developmentOnly
    runtimeClasspath {
        extendsFrom developmentOnly
    }
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    maven{ url 'https://maven.aliyun.com/repository/public'}
    mavenCentral()
}

def grpcVersion = '1.37.0' // CURRENT_GRPC_VERSION

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
    implementation "io.grpc:grpc-stub:${grpcVersion}"
    implementation "io.grpc:grpc-netty:${grpcVersion}"

    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }
}

test {
    useJUnitPlatform()
}

protobuf {
    protoc { artifact = "com.google.protobuf:protoc:3.15.2" }
    plugins {
        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
    }
    generateProtoTasks {
        all()*.plugins {
            grpc {}
        }
    }
    // 声明java类生成目录
    generatedFilesBaseDir = "$projectDir/src/generated"
}

3. 创建Protocol Buffers定义服务文件

在src/main目录下创建proto目录,然后在里面创建HelloService.proto文件编写如下内容;

syntax="proto3";
option java_multiple_files = true; // 这个地方注意 如果未设置true 会把所有message打包到一个类 单个java类最大限制65K 超出的化 java文件无法被识别引用
package example.grpc;

message HelloRequest {
    string firstName = 1;
    string lastName = 2;
}

message HelloResponse {
    string greeting = 1;
}

service HelloService {
    rpc hello(HelloRequest) returns (HelloResponse);
}

右键 执行 build module 在src目录下生成了generated文件夹

4. 创建服务端gRPC Service

用于处理请求并返回,就像我们spring controller接收的GetMapping请求一样

创建文件
src/main/example/grcp/service/HelloServiceImpl.java

package com.ben.grpcdemo;

import example.grpc.*;
import io.grpc.stub.StreamObserver;

public class HelloServiceImpl extends HelloServiceGrpc.HelloServiceImplBase {

    @Override
    public void hello(
            HelloRequest request, StreamObserver<HelloResponse> responseObserver) {
        System.out.println("Request received from client:\n" + request);

        String greeting = new StringBuilder().append("Hello, ")
                .append(request.getFirstName())
                .append(" ")
                .append(request.getLastName())
                .toString();

        HelloResponse response = HelloResponse.newBuilder()
                .setGreeting(greeting)
                .build();

        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

然后 利用Spring的启动器来启动gRPC服务端
用于给我们的客户端提供服务开启gRPC服务

创建文件
src/main/java/example/GrpcServerStartupRunner.java

package com.ben.grpcdemo;

import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.util.TransmitStatusRuntimeExceptionInterceptor;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class GrpcServerStartupRunner implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {
        ServerBuilder serverBuilder = ServerBuilder
                .forPort(8081)
                .addService(new HelloServiceImpl());

        Server server = serverBuilder.build();
        serverBuilder.intercept(TransmitStatusRuntimeExceptionInterceptor.instance());
        server.start();
        startDaemonAwaitThread(server);
    }

    private void startDaemonAwaitThread(Server server) {
        Thread awaitThread = new Thread(() -> {
            try {
                server.awaitTermination();
            } catch (InterruptedException ignore) {

            }
        });
        awaitThread.setDaemon(false);
        awaitThread.start();
    }
}

5. 创建客户端代码

我们直接在Spring Boot的Appliction文件里创建个get请求来调用gRPC的服务

修改 src/main/java/example/grpc/ExampleGrpcApplication.java

package com.ben.grpcdemo;

import com.google.common.base.Stopwatch;
import example.grpc.*;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class GrpcdemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(GrpcdemoApplication.class, args);
    }

    @GetMapping("/")
    public ResponseEntity test() {
        ManagedChannel channel = ManagedChannelBuilder.forAddress("127.0.0.1", 8081)
                .usePlaintext()
                .build();
        Stopwatch stopwatch = Stopwatch.createStarted();
        HelloServiceGrpc.HelloServiceBlockingStub stub
                = HelloServiceGrpc.newBlockingStub(channel);

        HelloResponse helloResponse = stub.hello(HelloRequest.newBuilder()
                .setFirstName("张")
                .setLastName("三")
                .build());
        System.out.println(stopwatch.stop());
        System.out.println("Response received from server:\n" + helloResponse);

        channel.shutdown();
        return ResponseEntity.ok(helloResponse.getGreeting());
    }

}

访问 http://localhost:8080/
返回 Hello, 张 三

引用文章: https://juejin.cn/post/684490...

评论

暂无评论