gRPC
上篇文章讲到 Protocol Buffers. 一些 API 也可以用 Protobuf 来表示。
简单介绍 RPC 的概念。Remote Procedure Call 具体的定义是指，将在远程跑的程序做得就像在本地运行一样。用 gRPC 生成的代码，形式上和本地的函数没有区别，而实际上是通过 Http 将请求发送到了服务器，在服务器运行。
在 Google 内部，用 Profobuf 来定义 API 几乎是通用的标准做法。gRPC 有很多前身，最后 Google 决定将项目开源。这是 gRPC 的由来。
具体什么是 gRPC？结合上篇对 Protobuf 的介绍，可以用 Protobuf 来表达 API。
如：
// The greeting service definition.
service Greeter {
// Sends a greeting
rpc SayHello (HelloRequest) returns (HelloReply) {}
}
// The request message containing the user's name.
message HelloRequest {
string name = 1;
}
// The response message containing the greetings
message HelloReply {
string message = 1;
}
gRPC 的官网给出了一个示例。这里 RPC 的 Request 和 Response 都写成了 Protobuf 的形式。额外地，有一个叫 service 的类型，其中定义了一个 RPC，SayHello，像一个普通的函数调用，会接收 Request 并返回 Response。
上面几行就定义了一个简单的 service，在编译生成以后，上述 Protobuf 会生成 Server stub 和 Client stub。分别用在 client 和 server 代码中。
例如，在 Java 中，server 可以使用
private class GreeterImpl extends GreeterGrpc.GreeterImplBase {
@Override
public void sayHello(HelloRequest req, StreamObserver responseObserver) {
HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
responseObserver.onNext(reply);
responseObserver.onCompleted();
}
}
client 可以使用
public void greet(String name) {
logger.info("Will try to greet " + name + " ...");
HelloRequest request = HelloRequest.newBuilder().setName(name).build();
HelloReply response;
try {
response = blockingStub.sayHello(request);
} catch (StatusRuntimeException e) {
logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
return;
}
logger.info("Greeting: " + response.getMessage());
}
这样就完成了一次 RPC 调用。
使用 gRPC 可以把 RPC 实现细节大大简化，比底层的网络和序列化的工作完全的封装起来。而且，由于 gRPC 和 Protobuf 深度绑定，所以可以很好地使用 proto 文件。
单个的接收和传输只是最简单的模式。实际上，gRPC 还支持流模式，单个收发只是流模式的一种特例。流模式可以分为 client 单向流，server 单向流，双向流。下面是一个双向流的例子。
public void routeChat() throws Exception {
info("*** RoutChat");
final CountDownLatch finishLatch = new CountDownLatch(1);
StreamObserver requestObserver =
asyncStub.routeChat(new StreamObserver() {
@Override
public void onNext(RouteNote note) {
info("Got message \"{0}\" at {1}, {2}", note.getMessage(), note.getLocation()
.getLatitude(), note.getLocation().getLongitude());
}
@Override
public void onError(Throwable t) {
Status status = Status.fromThrowable(t);
logger.log(Level.WARNING, "RouteChat Failed: {0}", status);
finishLatch.countDown();
}
@Override
public void onCompleted() {
info("Finished RouteChat");
finishLatch.countDown();
}
});
try {
RouteNote[] requests =
{newNote("First message", 0, 0), newNote("Second message", 0, 1),
newNote("Third message", 1, 0), newNote("Fourth message", 1, 1)};
for (RouteNote request : requests) {
info("Sending message \"{0}\" at {1}, {2}", request.getMessage(), request.getLocation()
.getLatitude(), request.getLocation().getLongitude());
requestObserver.onNext(request);
}
} catch (RuntimeException e) {
// Cancel RPC
requestObserver.onError(e);
throw e;
}
// Mark the end of requests
requestObserver.onCompleted();
// Receiving happens asynchronously
finishLatch.await(1, TimeUnit.MINUTES);
}
在这里，我们先定义了一个 StreamObserver<RouteNote>，用来接收来自 server 的返回流，
StreamObserver<RouteNote> requestObserver = asyncStub.routeChat(StreamObserver)
用这个 StreamObserver 建立一个 RequestObserver 用来从 client 发送数据。
for (RouteNote request : requests) {
info("Sending message \"{0}\" at {1}, {2}", request.getMessage(), request.getLocation()
.getLatitude(), request.getLocation().getLongitude());
requestObserver.onNext(request);
}
就是发送数据的过程。
可以将这个过程理解为两个不相关的通路。数据独立地发送，也独立地被接收。
gRPC 的性能比常用的 JSON 优越很多。具体好多少呢？
https://github.com/david-cao/gRPCBenchmarks
GitHub 上有一个在 Android 上测试的 Benchmark，可以看到 gRPC 的性能是大大优越的。
