gRpc的四种通信方式详细介绍
博主猫头虎 带您 Go to New World.✨
博客首页——猫头虎的博客
《面试题大全专栏》 文章图文并茂生动形象简单易学！欢迎大家来踩踩~
《IDEA开发秘籍专栏》学会IDEA常用操作，工作效率翻倍~
《100天精通Golang(基础入门篇）》学会Golang语言，畅玩云原生，走遍大小厂~
希望本文能够给您带来一定的帮助文章粗浅，敬请批评指正！
文章目录
- gRpc的四种通信方式
-
- 四种通信方式
- 简单RPC(一元RPC)
-
- 特点
- 语法
- 服务端流式RPC
-
- 特点
- 使用场景
- 语法
- 关键代码
- 客户端流式RPC
-
- 应用场景
- proto
- 开发
- 双向流式RPC
-
- 应用场景
- 编码
- **总结**：
- **参考资料**：
- 原创声明
gRpc的四种通信方式
四种通信方式
- 简单rpc 一元rpc (Unary RPC)
- 服务端流式RPC (Server Streaming RPC)
- 客户端流式RPC (Client Streaming RPC)
- 双向流RPC (Bi-directional Stream RPC)
摘要：
本文详细介绍了gRpc的四种主要通信方式，包括简单RPC、服务端流式RPC、客户端流式RPC和双向流式RPC。每种方式都有其特点和应用场景，以及相应的代码实现。
导语：
在分布式系统中，通信是至关重要的。gRpc作为一个高性能、开源和通用的RPC框架，为我们提供了多种通信方式。那么，这些通信方式都有哪些特点和应用场景呢？让我们一起深入了解。
引言：
“通信是连接分布式系统的桥梁，而gRpc则为我们提供了这座桥梁的多种形式。从简单的一对一通信到复杂的双向流通信，gRpc都能为我们提供稳定和高效的解决方案。”
简单RPC(一元RPC)
- 第一个RPC程序，实际上就是一元RPC
特点
当client发起调用后，提交数据，并且等待 服务端响应。开发过程中，主要采用就是一元RPC的这种通信方式。
语法
service HelloService{
rpc hello(HelloRequest) returns (HelloResponse){}
rpc hello1(HelloRequest1) returns (HelloResponse1){}
}
服务端流式RPC
一个请求对象，服务端可以回传多个结果对象。
特点
使用场景
client --------> Server
股票标号
<-------
某一个时刻的 股票的行情
语法
service HelloService{
rpc hello(HelloRequest) returns (stream HelloResponse){}
rpc hello1(HelloRequest1) returns (HelloResponse1){}
}
关键代码
服务端
public void c2ss(HelloProto.HelloRequest request, StreamObserver<HelloProto.HelloResponse> responseObserver) {
//1 接受client的请求参数
String name = request.getName();
//2 做业务处理
System.out.println("name = " + name);
//3 根据业务处理的结果，提供响应
for (int i = 0; i < 9; i++) {
HelloProto.HelloResponse.Builder builder = HelloProto.HelloResponse.newBuilder();
builder.setResult("处理的结果 " + i);
HelloProto.HelloResponse helloResponse = builder.build();
responseObserver.onNext(helloResponse);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
responseObserver.onCompleted();
}
客户端
public class GprcClient3 {
public static void main(String[] args) {
ManagedChannel managedChannel = ManagedChannelBuilder.forAddress("localhost", 9000).usePlaintext().build();
try {
HelloServiceGrpc.HelloServiceBlockingStub helloService = HelloServiceGrpc.newBlockingStub(managedChannel);
HelloProto.HelloRequest.Builder builder = HelloProto.HelloRequest.newBuilder();
builder.setName("sunshuai");
HelloProto.HelloRequest helloRequest = builder.build();
Iterator<HelloProto.HelloResponse> helloResponseIterator = helloService.c2ss(helloRequest);
while (helloResponseIterator.hasNext()) {
HelloProto.HelloResponse helloResponse = helloResponseIterator.next();
System.out.println("helloResponse.getResult() = " + helloResponse.getResult());
}
} catch (Exception e) {
e.printStackTrace();
}
finally {
managedChannel.shutdown();
}
}
}
监听 异步方式 处理服务端流式RPC的开发
1. api
2. 服务端
3. 客户端
public class GrpcClient4 {
public static void main(String[] args) {
ManagedChannel managedChannel = ManagedChannelBuilder.forAddress("localhost", 9000).usePlaintext().build();
try {
HelloServiceGrpc.HelloServiceStub helloService = HelloServiceGrpc.newStub(managedChannel);
HelloProto.HelloRequest.Builder builder = HelloProto.HelloRequest.newBuilder();
builder.setName("xiaohei");
HelloProto.HelloRequest helloRequest = builder.build();
helloService.c2ss(helloRequest, new StreamObserver<HelloProto.HelloResponse>() {
@Override
public void onNext(HelloProto.HelloResponse value) {
//服务端 响应了 一个消息后，需要立即处理的话。把代码写在这个方法中。
System.out.println("服务端每一次响应的信息 " + value.getResult());
}
@Override
public void onError(Throwable t) {
}
@Override
public void onCompleted() {
//需要把服务端 响应的所有数据 拿到后，在进行业务处理。
System.out.println("服务端响应结束 后续可以根据需要 在这里统一处理服务端响应的所有内容");
}
});
managedChannel.awaitTermination(12, TimeUnit.SECONDS);
} catch (Exception e) {
e.printStackTrace();
} finally {
managedChannel.shutdown();
}
}
}
客户端流式RPC
客户端发送多个请求对象，服务端只返回一个结果。
应用场景
IOT(物联网 【传感器】) 向服务端 发送数据
proto
rpc cs2s(stream HelloRequest) returns (HelloResponse){}
开发
1. api
rpc cs2s(stream HelloRequest) returns (HelloResponse){}
2. 服务端开发
public StreamObserver<HelloProto.HelloRequest> cs2s(StreamObserver<HelloProto.HelloResponse> responseObserver) {
return new StreamObserver<HelloProto.HelloRequest>() {
@Override
public void onNext(HelloProto.HelloRequest value) {
System.out.println("接受到了client发送一条消息 " + value.getName());
}
@Override
public void onError(Throwable t) {
}
@Override
public void onCompleted() {
System.out.println("client的所有消息 都发送到了 服务端 ....");
//提供响应：响应的目的：当接受了全部client提交的信息，并处理后，提供相应
HelloProto.HelloResponse.Builder builder = HelloProto.HelloResponse.newBuilder();
builder.setResult("this is result");
HelloProto.HelloResponse helloResponse = builder.build();
responseObserver.onNext(helloResponse);
responseObserver.onCompleted();
}
};
}
3. 客户端开发
public class GrpcClient5 {
public static void main(String[] args) {
ManagedChannel managedChannel = ManagedChannelBuilder.forAddress("localhost", 9000).usePlaintext().build();
try {
HelloServiceGrpc.HelloServiceStub helloService = HelloServiceGrpc.newStub(managedChannel);
StreamObserver<HelloProto.HelloRequest> helloRequestStreamObserver = helloService.cs2s(new StreamObserver<HelloProto.HelloResponse>() {
@Override
public void onNext(HelloProto.HelloResponse value) {
// 监控响应
System.out.println("服务端 响应 数据内容为 " + value.getResult());
}
@Override
public void onError(Throwable t) {
}
@Override
public void onCompleted() {
System.out.println("服务端响应结束 ... ");
}
});
//客户端 发送数据 到服务端 多条数据 ，不定时...
for (int i = 0; i < 10; i++) {
HelloProto.HelloRequest.Builder builder = HelloProto.HelloRequest.newBuilder();
builder.setName("sunshuai " + i);
HelloProto.HelloRequest helloRequest = builder.build();
helloRequestStreamObserver.onNext(helloRequest);
Thread.sleep(1000);
}
helloRequestStreamObserver.onCompleted();
managedChannel.awaitTermination(12, TimeUnit.SECONDS);
} catch (Exception e) {
e.printStackTrace();
} finally {
managedChannel.shutdown();
}
}
}
双向流式RPC
客户端可以发送多个请求消息，服务端响应多个响应消息。
应用场景
聊天室
编码
1. api
rpc cs2ss(stream HelloRequest) returns (stream HelloResponse){}
2. 服务端
public StreamObserver<HelloProto.HelloRequest> cs2ss(StreamObserver<HelloProto.HelloResponse> responseObserver) {
return new StreamObserver<HelloProto.HelloRequest>() {
@Override
public void onNext(HelloProto.HelloRequest value) {
System.out.println("接受到client 提交的消息 "+value.getName());
responseObserver.onNext(HelloProto.HelloResponse.newBuilder().setResult("response "+value.getName()+" result ").build());
}
@Override
public void onError(Throwable t) {
}
@Override
public void onCompleted() {
System.out.println("接受到了所有的请求消息 ... ");
responseObserver.onCompleted();
}
};
}
3. 客户端
public class GrpcClient6 {
public static void main(String[] args) {
ManagedChannel managedChannel = ManagedChannelBuilder.forAddress("localhost", 9000).usePlaintext().build();
try {
HelloServiceGrpc.HelloServiceStub helloService = HelloServiceGrpc.newStub(managedChannel);
StreamObserver<HelloProto.HelloRequest> helloRequestStreamObserver = helloService.cs2ss(new StreamObserver<HelloProto.HelloResponse>() {
@Override
public void onNext(HelloProto.HelloResponse value) {
System.out.println("响应的结果 "+value.getResult());
}
@Override
public void onError(Throwable t) {
}
@Override
public void onCompleted() {
System.out.println("响应全部结束...");
}
});
for (int i = 0; i < 10; i++) {
helloRequestStreamObserver.onNext(HelloProto.HelloRequest.newBuilder().setName("sunshuai " + i).build());
}
helloRequestStreamObserver.onCompleted();
managedChannel.awaitTermination(12, TimeUnit.SECONDS);
} catch (Exception e) {
e.printStackTrace();
} finally {
managedChannel.shutdown();
}
}
}
这篇博客简要介绍了gRpc的四种通信方式，包括简单RPC、服务端流式RPC、客户端流式RPC和双向流式RPC，并给出了每种方式的特点、使用场景、语法和关键代码。希望对读者有所帮助。
总结：
gRpc的四种通信方式为分布式系统提供了强大的支持。简单RPC适用于常规的请求-响应模式，服务端流式RPC和客户端流式RPC分别允许服务端和客户端发送多个消息，而双向流式RPC则支持双方的双向通信。了解这些通信方式及其应用场景，可以帮助我们更好地设计和实现分布式系统。
参考资料：
- gRpc官方文档：https://grpc.io/docs/
- “Mastering gRpc” by Alex Konrad.
- “Distributed Systems with gRpc” by Sarah Allen.
原创声明
======= ·
- 原创作者： 猫头虎
作者wx： [ libin9iOak ]
| 学习 | 复习 |
|---|---|
| ✔ |
本文为原创文章，版权归作者所有。未经许可，禁止转载、复制或引用。
作者保证信息真实可靠，但不对准确性和完整性承担责任。
未经许可，禁止商业用途。
如有疑问或建议，请联系作者。
感谢您的支持与尊重。
点击
下方名片，加入IT技术核心学习团队。一起探索科技的未来，共同成长。