SpringBoot集成grpc实现微服务

前言

传统的SpringCloud实现微服务的方案中，我们通常都是使用SpringCloud OpenFeign组件以RESTFUL API的调用方式来完成微服务之间的RPC调用；使用RESTFUL API的方式在SpringCloud实施的微服务在实际的项目中还是非常常见的；在实现上比较的简单，而且关于RPC调用中的服务熔断等处理的组件也支持的较多；一般的SpringCloud都是采用OpenFeign通过HTTP的方式；今天我们这个文章给大家介绍一种在云原生中应用的更为广泛的RPC调用的方式gRPC； 并看看SpringBoot如何集成gRPC实现一个微服务。

gRPC

gRPC，也是RPC框架的一种，可以看作是g-RPC；是一个高性能、开源和通用的 RPC 框架，基于ProtoBuf(Protocol Buffers) 序列化协议开发，且支持众多开发语言。面向服务端和移动端，基于 HTTP/2 设计，带来诸如双向流、流控、头部压缩、单 TCP 连接上的多复用请求等特。这些特性使得其在移动设备上表现更好，更省电和节省空间占用。 gRPC的方式有点和JAVA技术里的RMI相识， ProtoBuf会产生一个类似RMI技术中Stub（桩子）;在Stub中包括了协议解析Marshal和Unmarshel，以及协议通过Tcp/IP进行通信的接口和实现类，在调用的时候，我们直接调用这个实现类的接口，即可完成和目标通信以及远程调用的细节实现；和RMI不同点就是协议方式不同，gRPC使用的是Protobut的协议进行数据传输；

如下图所示；

gRPC和RESTFUL的比较

gRPC 优点

性能

gRPC 消息使用 Protobuf（一种高效的二进制消息格式）进行序列化。 Protobuf 在服务器和客户端上可以非常快速地序列化。 Protobuf 序列化产生的有效负载较小，这在移动应用等带宽有限的方案中很重要。

gRPC 专为 HTTP/2（HTTP 的主要版本）而设计，与 HTTP 1.x 相比，HTTP/2 具有巨大性能优势：

• 二进制组帧和压缩。 HTTP/2 协议在发送和接收方面均紧凑且高效。
• 在单个 TCP 连接上多路复用多个 HTTP/2 调用。 多路复用可消除队头阻塞。

HTTP/2 不是 gRPC 独占的。 许多请求类型（包括具有 JSON 的 HTTP API）都可以使用 HTTP/2，并受益于其性能改进。

代码生成

所有 gRPC 框架都为代码生成提供一流支持。 .proto文件是 gRPC 开发的核心文件，它定义 gRPC 服务和消息的协定。 通过此文件，gRPC 框架生成服务基类、消息和完整的客户端。

通过在服务器和客户端之间共享 .proto 文件，可以端到端生成消息和客户端代码。 客户端的代码生成消除了客户端和服务器上的消息重复，并为你创建强类型客户端。 无需编写客户端可在具有许多服务的应用程序中节省大量开发时间。

严格规范

具有 JSON 的 HTTP API 没有正式规范。 开发人员为 URL、HTTP 谓词和响应代码的最佳格式争论不休。

gRPC 规范对 gRPC 服务必须遵循的格式进行了规定。 gRPC 消除了争论并为开发人员节省了时间，因为 gRPC 在各个平台和实现中都是一致的。

流式处理

HTTP/2 为长期实时通信流提供基础。 gRPC 为通过 HTTP/2 进行流式传输提供一流支持。

gRPC 服务支持所有流式传输组合：

• 一元（无流式传输）
• 服务器到客户端流式传输
• 客户端到服务器流式传输
• 双向流式传输

截止时间/超时和取消

gRPC 允许客户端指定其愿意等待 RPC 完成的时间期限。 截止时间会发送到服务器，如果超过截止时间，服务器可以决定要执行的操作。 例如，服务器可能会在超时后取消正在进行的 gRPC/HTTP/数据库请求。

通过 gRPC 子调用传播截止时间和取消有助于强制执行资源使用限制。

gRPC使用流程

定义标准的proto文件

生成标准代码

服务端使用生成的代码提供服务

客户端使用生成的代码调用服务

SpringBoot基础gRPC

定义proto文件作为服务标准

syntax = "proto3";

package service;
option java_multiple_files = false;
option java_package = "com.joinsun.application.dubbo.demo.protobuf";
option java_outer_classname = "HelloGrpcServiceProto";
option go_package = "./hello_grpc";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
  rpc SayHelloOutStream (HelloRequest) returns (stream HelloReply) {}
  rpc SayHelloInStream (stream HelloRequest) returns (HelloReply) {}
  rpc SayHelloBothStream (stream HelloRequest) returns (stream HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}


message HelloRequest {

string name = 1;

}



message HelloReply {

string message = 1;

}

生成标准代码

在pom.xml中加入proto文件处理的插件，这样在maven进行springboot项目构建的时候，会自动进行proto的文件构建

在pom.xml的build-》plugins部分，添加支持proto文件的插件

    <plugin>
        <groupId>org.xolstice.maven.plugins</groupId>
        <artifactId>protobuf-maven-plugin</artifactId>
        <version>0.5.0</version>
        <configuration>
            <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
            <pluginId>grpc-java</pluginId>
            <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
            <outputDirectory>src/main/java</outputDirectory>
            <clearOutputDirectory>false</clearOutputDirectory>            
        </configuration>
        <executions>
            <execution>
                <goals>
                    <goal>compile</goal>
                    <goal>compile-custom</goal>
                </goals>
            </execution>
        </executions>
    </plugin>

上面的插件里，相关的一些属性参数；如下

<properties>
    <dubbo.protobuf.verion>2.7.14</dubbo.protobuf.verion>
    <dubbo.compiler.version>0.0.2</dubbo.compiler.version>
    <grpc.version>1.6.1</grpc.version>
    <protobuf.version>3.3.0</protobuf.version>
    <protobuf.format.version>1.2</protobuf.format.version>
</properties>

编译以后的内容

编写服务端代码（实现业务逻辑）

加入依赖

引入上面编译后产生的proto文件； 编写服务提供方的业务逻辑代码

在pom文件里加入grpc的依赖

        <!--    GRPC    -->
        <dependency>
            <groupId>org.lognet</groupId>
            <artifactId>grpc-spring-boot-starter</artifactId>
            <version>${grpc-spring-boot-starter.version}</version>
        </dependency>

编写业务代码

@GRpcService
public class OperateImpl extends GreeterGrpc.GreeterImplBase {
    @Override
    public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
String msg = String.format("Protobuf: Hello, %s %s", request.getName(), DateUtil.formatDateTime(DateUtil.date()));

return HelloGrpcServiceProto.HelloReply.newBuilder().setMessage(msg).build();
     }
}

编写消费端代码（调用服务）

加入依赖

引入上面编译后产生的proto文件； 编写服务提供方的业务逻辑代码

在pom文件里加入grpc的依赖

        <!--    GRPC    -->
        <dependency>
            <groupId>org.lognet</groupId>
            <artifactId>grpc-spring-boot-starter</artifactId>
            <version>${grpc-spring-boot-starter.version}</version>
        </dependency>

调用服务

@Component
@Slf4j
public class GRpcService {
    private Channel serverChannel;

    @Setter
    @Value("${grpc.client.grpc-server.host:localhost}")
    private String host;

    @Setter
    @Value("${grpc.client.grpc-server.port:8098}")
    private int port;

    @PostConstruct
    public void init(){
        ManagedChannel managedChannel = ManagedChannelBuilder.forAddress(host, port).usePlaintext(true).build();
        this.serverChannel = managedChannel;
    }

    public String sayHello(String word){
        GreeterGrpc.GreeterStub stub = GreeterGrpc.newBlockingStub(serverChannel);

        HelloGrpcServiceProto.HelloReply helloReply = stub.sayHello(HelloGrpcServiceProto.HelloRequest.newBuilder().setName(word).build());

        return helloReply.getMessage();
    }

    public String sayHelloStream(String word){
        GreeterGrpc.GreeterStub stub = GreeterGrpc.newStub(serverChannel);

        stub.sayHelloOutStream(HelloGrpcServiceProto.HelloRequest.newBuilder().setName(word+"-Java-Out").build(), new StreamObserver<HelloGrpcServiceProto.HelloReply>() {
            @Override
            public void onNext(HelloGrpcServiceProto.HelloReply helloReply) {
                log.info("Receiver[Out] {}", helloReply.getMessage());
            }

            @Override
            public void onError(Throwable throwable) {
                log.info("Error[Out] {}", throwable);
            }

            @Override
            public void onCompleted() {
                log.info("Receive[Out] finish");
            }
        });

        StreamObserver<HelloGrpcServiceProto.HelloRequest> requestStreamObserver =
                stub.sayHelloInStream(new StreamObserver<HelloGrpcServiceProto.HelloReply>() {
            @Override
            public void onNext(HelloGrpcServiceProto.HelloReply helloReply) {
                log.info("Receiver[In] {}", helloReply.getMessage());
            }

            @Override
            public void onError(Throwable throwable) {
                log.info("Error[In] {}", throwable);
            }

            @Override
            public void onCompleted() {
                log.info("Receive[In] finish");
            }
        });

        for( int idx = 1; idx <= 10; idx ++) {
            requestStreamObserver.onNext(HelloGrpcServiceProto.HelloRequest.newBuilder().setName(word+"-Java-In-"
                    + idx).build());
        }

        requestStreamObserver.onCompleted();

        requestStreamObserver =
                stub.sayHelloBothStream(new StreamObserver<HelloGrpcServiceProto.HelloReply>() {
            @Override
            public void onNext(HelloGrpcServiceProto.HelloReply helloReply) {
                log.info("Receiver[Both] {}", helloReply.getMessage());
            }

            @Override
            public void onError(Throwable throwable) {
                log.info("Error[Both] {}", throwable);
            }

            @Override
            public void onCompleted() {
                log.info("Receive[Both] finish");
            }
        });

        for( int idx = 1; idx <= 10; idx ++) {
            requestStreamObserver.onNext(HelloGrpcServiceProto.HelloRequest.newBuilder().setName(word+"-Java-Both-"
                    + idx).build());
        }

        requestStreamObserver.onCompleted();

        return "OK";
    }
}

在上述消费者进行RPC远程调用的代码中，我们演示了2中调用，一种是普通调用，一种是单向流的调用；

部署服务端和消费端

将服务端和客户端都启动，通过消费端的GRpcService的调用，就可以实现grpc的远程调用了

结束语

本文介绍了gRpc这种在云原生里非常使用非常广泛的RPC调用方式，并介绍了通过Springboot的方式集成gRPC进行java语言的gRPC调用的实战案例；gRPC的调用是跨语言的，有兴趣的朋友可以使用GO语言来实现对Java实现的服务端调用；通过对比，你会发现Go对gRPC的调用支持比Java是更加的方便。

谢谢大家继续关注！！！