原文：
gRPC初探——概念介绍以及如何构建一个简单的gRPC服务 – takumiCX – 博客园
gRPC初探——概念介绍以及如何构建一个简单的gRPC服务
目录
对于分布式系统而言,不同的服务分布在不同的节点上,一个服务要完成自己的功能经常需要调用其他服务的接口,比如典型的微服务架构。通常这种服务调用方式有两种,一种是发送HTTP请求的方式,另一种则是RPC的方式,RPC是Remote Procedure Call(远程过程调用)的简称,可以让我们像调用本地接口一样使用远程服务。相比HTTP调用,RPC的方式至少在以下几个方面有优势
-
传输效率
RPC可以自定义TCP报文,基于TCP协议进行通信,比如dubbo;同时也支持使用HTTP2协议进行通信,比如gRPC。这相比传统的HTTP1.1协议报文体积会更小,传输效率会更高。 -
性能消耗
RPC框架通常自带高效的序列化机制,序列化和反序列化耗时更低,序列化后的字节数通常也更小。 -
负责均衡
RPC框架通常自带负载均衡策略,而HTTP请求要做负载均衡需要外部应用如Nginx的支持。 -
服务治理
下游服务新增,重启,下线时能自动通知上游使用者,而HTTP的方式需要事先通知并修改相关配置。
正因为基于RPC方式的服务调用有着性能消耗低,传输效率高,更容易做负载均衡和服务治理的优点,所以分布式系统内部大多采用这种方式进行分布式服务调用。可供选择的RPC框架很多,比如Hession,Dubbo,Thrift这些很早就开源,平时项目中使用也很多。不过最近有一个叫gRPC的RPC框架很火,被使用在很多微服务相关的开源项目中,比如华为的Apache ServiceComb Saga。这篇博客作为我学习gRPC的入门笔记,只对它的核心概念和简单用法做些介绍
1. gRPC简介
gRPC是由Google开发并开源的RPC框架,它具有以下特点
-
语言中立
支持C,Java,Go等多种语言来构建RPC服务,这是gRPC被广泛的应用在微服务项目中的重要原因,因为不同的微服务可能用不同的语言构建。 -
基于HTTP/2协议
支持双向流,消息头压缩,单TCP的多路复用,服务端推送等,这些特性使得gRPC更加适用于移动场景下的客户端和服务端之间的通信。 -
基于IDL定义服务
编写.proto文件即可生成特定语言的数据结构、服务端接口和客户端Stub。 -
支持Protocol Buffer序列化
Protocol Buffer是由Google开发的一种数据序列化协议(类似于XML、JSON、Hession),平台无关,压缩和传输效率高,语法简单,表达能力强。
一个gRPC服务的大体架构可以用官网上的一幅图表示
gRPC服务端使用C++构建,客户端可以使用Ruby或者Java构建,客户端通过一个Stub存根(代理)对象发起RPC调用,请求和响应消息都使用Protocol Buffer进行序列化。
当我们在微服务中使用gRPC时,整个服务调用过程如下所示(图片来自网络)
通过gRPC,远程服务的调用对使用者更加简单和透明,底层的传输方式,序列化方式,通信细节等统统不需要关系,当然这些对其他RPC框架而言也适用。
2. 使用Protocol Buffers进行服务定义
一个直观的想法,在客户端调用服务端提供的远程接口前,双方必须进行一些约定,比如接口的方法签名,请求和响应的数据结构等,这个过程称为服务定义。服务定义需要特定的接口定义语言(IDL)来完成,gRPC中默认使用protocol buffers。它是google很早就开源的一款序列化框架,其定义了一种数据序列化协议,独立于语言和平台,提供了多种语言的实现:Java,C++,Go等,每一种实现都包含了相应语言的编译器和库文件。使用它进行服务定义需要编写.proto后缀的IDL文件,并通过其编译器生成特定语言的数据结构、服务端接口和客户端Stub代码。
2.1 定义消息
消息是表示RPC接口的请求参数和响应结果的数据结构。如下定义了一个请求消息和响应消息
//定义请求消息的结构
message SearchResponse {
// repeated表示该字段可以重复任意次,等价于数组:Result[]
repeated Result result = 1;
}
//定义响应消息的结构
message Result {
//required表示该字段的值恰好为1个
required string url = 1;
//optional表示该字段的值为0或1个
optional string title = 2;
repeated string snippets = 3;
}
定义消息的关键字为message,相当于java中的class关键字,一个消息就相当于java中的一个类。消息内可以有多个字段,字段的类型可以分类如下
-
基本数据类型
int32表示java中的int,int64表示java中的long,string表示java中的string,具体的对应关系如下表所示
-
复杂数据类型
枚举,map等。
enum Corpus {
UNIVERSAL = 0;
WEB = 1;
IMAGES = 2;
LOCAL = 3;
NEWS = 4;
PRODUCTS = 5;
VIDEO = 6;
}
map<key_type, value_type> map_field = N;
和java中类中可以定义类一样,Protocol Buffers中消息内也可以定义消息,形成多层的嵌套结构
message Outer { // Level 0
message MiddleAA { // Level 1
message Inner { // Level 2
required int64 ival = 1;
optional bool booly = 2;
}
}
关于消息定义,有几点需要注意的地方
1.消息中的字段前可以有修饰符,修饰符主要有三种
-
required
required int64 ival = 1;
该字段的值恰好只有一个,没有或传入多个都将报错。 -
optional
optional int32 result_per_page = 3 [default = 10];
该字段的值有0个或1个,传入多个将报错。且以optional修饰的字段可以设置默认值,若没有设置,则编译器会根据类型自动设置一个默认值,比如string设置为空字符串,bool类型设置为false等。 -
repeated
repeated int32 samples = 4
该字段相当于java中的数组,可以有0个或多个值。
2.消息中的字段有唯一编号,如下所示
这个唯一编号用来在消息的二进制格式中进行字段的区分,范围从1-229 – 1,其中19000-19999是保留编号不能使用。这些字段编号在使用过程中不能进行修改,否则会出现问题。
2.2 定义服务接口
标题中的接口可以类比java中的Interface,内部可以有多个方法。gRPC中使用service关键定义服务接口
service HelloService {
rpc SayHello (HelloRequest) returns (HelloResponse);
}
message HelloRequest {
string greeting = 1;
}
message HelloResponse {
string reply = 1;
}
该服务接口HelloService内部只有一个rpc方法SayHello,请求参数为HelloRequest,响应结果为HelloResponse。
grpc中可以定义4中类型的rpc方法
- 1.简单rpc方法
rpc SayHello(HelloRequest) returns (HelloResponse){
}
客户端发送一个请求,从服务端获得一个响应,整个过程就像一个本地的方法调用。
- 2.服务端流式响应的rpc方法
rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse){
}
客户端发送一个请求,并从服务端获得一个流(stream)。服务端可以往流中写入N个消息作为响应,并且每个消息可以单独发送,客户端可以从流中按顺序读取这些消息,如下图所示(图片来自网络)
- 3.客户端流式请求的rpc方法
rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse) {
}
客户端通过流发送一连串的多个请求,并等待从服务端返回的一个响应。
- 4.双向流式rpc方法
rpc BidiHello(stream HelloRequest) returns (stream HelloResponse){
}
客户端通过流发送N个请求,服务端通过流发送N个响应,彼此相互独立,并且读写没有特定的次序要求,比如服务端可以收到所有请求后再返回响应,也可以每读取一个或K个请求会返回响应。
该特性可以充分利用HTTP/2.0的多路复用功能,实现了服务端和客户端的全双工通信,如下图所示(图片来自网络)
3.构建简单的gRPC服务
按照惯例,编写一个gRPC版本的hello world来讲解如何构建一个简单的gRPC服务——客户端发送一个请求,服务端返回一个响应。
比如
客户端:
takumiCX
服务端:
Hello takumiCX
3.1 编写proto文件,定义消息和接口
-
创建proto文件
-
定义消息和接口
//Protocal Buffers的版本有v2和v3之分,语法有较多变化,且相互不兼容
//这里使用的v3版本的
syntax = "proto3";
//编译后生成的消息类HelloRequest和HelloReply是否分别放在单独的class文件中
option java_multiple_files = true;
//生成代码的包路径
option java_package = "com.takumiCX.greeter";
//最外层的类名称
option java_outer_classname = "HelloWorldProto";
//包命名空间
package helloworld;
// 服务接口
service Greeter {
// 一个简单的rpc方法
rpc SayHello (HelloRequest) returns (HelloReply) {}
}
// 请求消息
message HelloRequest {
string name = 1;
}
// 响应消息
message HelloReply {
string message = 1;
}
3.2 通过maven插件生成相应代码
- pom文件配置如下
<dependencies>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-netty-shaded</artifactId>
<version>1.16.1</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-protobuf</artifactId>
<version>1.16.1</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-stub</artifactId>
<version>1.16.1</version>
</dependency>
</dependencies>
<build>
<extensions>
<extension>
<groupId>kr.motd.maven</groupId>
<artifactId>os-maven-plugin</artifactId>
<version>1.5.0.Final</version>
</extension>
</extensions>
<plugins>
<plugin>
<groupId>org.xolstice.maven.plugins</groupId>
<artifactId>protobuf-maven-plugin</artifactId>
<version>0.5.1</version>
<configuration>
<protocArtifact>com.google.protobuf:protoc:3.5.1-1:exe:${os.detected.classifier}</protocArtifact>
<pluginId>grpc-java</pluginId>
<pluginArtifact>io.grpc:protoc-gen-grpc-java:1.16.1:exe:${os.detected.classifier}</pluginArtifact>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>compile-custom</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
在target目录下可以看到编译器通过编译proto文件为我们生成了对应的类,如下图所示
3.3 gRPC服务端创建
- 第一步:首先要创建一个具体的服务接口实现类GreeterImpl,扩展gRPC为我们生成的服务抽象类GreeterGrpc.GreeterImplBase,重写服务方法
//扩展gRPC自动生成的服务接口抽象,实现业务功能
static class GreeterImpl extends GreeterGrpc.GreeterImplBase{
@Override
public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
//构建响应消息,从请求消息中获取姓名,在前面拼接上"Hello "
HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + request.getName()).build();
//在流关闭或抛出异常前可以调用多次
responseObserver.onNext(reply);
//关闭流
responseObserver.onCompleted();
}
}
- 创建server对象,监听特定端口,注册具体的服务实现类并启动
//服务要监听的端口
int port=50051;
//创建server对象,监听端口,注册服务并启动
Server server = ServerBuilder.
forPort(port) //监听50051端口
.addService(new GreeterImpl()) //注册服务
.build() //创建Server对象
.start(); //启动
log.info("Server started,listening on "+port);
server.awaitTermination();
完整代码如下
/**
* @author: takumiCX
* @create: 2018-12-01
**/
public class HelloWorldServer {
private static final Logger log=Logger.getLogger(HelloWorldServer.class.getName());
//扩展gRPC自动生成的服务接口,实现业务功能
static class GreeterImpl extends GreeterGrpc.GreeterImplBase{
@Override
public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
//构建响应消息,从请求消息中获取姓名,在前面拼接上"Hello "
HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + request.getName()).build();
//在流关闭或抛出异常前可以调用多次
responseObserver.onNext(reply);
//关闭流
responseObserver.onCompleted();
}
}
public static void main(String[] args) throws IOException, InterruptedException {
//服务要监听的端口
int port=50051;
//创建服务对象,监听端口,注册服务并启动
Server server = ServerBuilder.
forPort(port) //监听50051端口
.addService(new GreeterImpl()) //注册服务
.build() //创建Server对象
.start(); //启动
log.info("Server started,listening on "+port);
server.awaitTermination();
}
}
gRPC的服务端创建过程如下所示(图片来自网络)
3.5 gRPC客户端创建
整个过程可以分为3步
- 1.根据服务端的ip和端口号,创建ManagedChannel
- 2.创建供客户端使用的stub对象,可以创建两种类型的stub,一种进行同步调用,一种进行异步调用,后者发起调用的业务线程不会同步阻塞。
- 3.通过stub对象发起rpc调用,获取服务端响应。
完整代码如下:
/**
* @author: takumiCX
* @create: 2018-12-01
**/
public class HelloWorldClient {
private static final Logger log=Logger.getLogger(HelloWorldClient.class.getName());
public static void main(String[] args) {
String host="localhost";
int port=50051;
//1.创建ManagedChannel,绑定服务端ip地址和端口
ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port)
.usePlaintext()
.build();
//2.获得同步调用的stub对象
GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(channel);
// //获得异步调用的stub对象
// GreeterGrpc.GreeterFutureStub futureStub = GreeterGrpc.newFutureStub(channel);
Scanner scanner = new Scanner(System.in);
while (true){
//从控制台读取用户输入
String name = scanner.nextLine().trim();
//构建请求消息
HelloRequest helloRequest = HelloRequest.newBuilder().setName(name).build();
//通过stub代理对象进行服务调用,获取服务端响应
HelloReply helloReply = stub.sayHello(helloRequest);
final String message = helloReply.getMessage();
log.warning("Greeting: "+message);
}
}
}
gRPC客户端的调用流程如下所示
3.6 测试
先启动gRPC服务端,然后启动gRPC客户单。客户端发送gRPC请求
takumiCX
,收到了来自服务端的响应
Hello takumiCX
4. 总结
gRPC作为开源RPC框架的新势力,基于HTTP/2.0协议进行设计,使用高性能的Protocol Buffer进行消息的序列化,因而性能非常好,而且提供了完整的负载均衡和服务治理能力,加上其和语言无关、平台无关的特点,非常适合作为微服务内部服务间调用的选型。
5. 参考资料
《深入浅出gRPC》
https://developers.google.com/protocol-buffers/
Core concepts, architecture and lifecycle | gRPC