AI 助理
文档备案控制台
开发者社区 IoT 文章 正文

gRpc的四种通信方式详细介绍

2023-10-14 761
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： gRpc的四种通信方式详细介绍

🌷🍁 博主猫头虎 带您 Go to New World.✨🍁

🦄 博客首页——猫头虎的博客🎐

🐳《面试题大全专栏》 文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺

🌊 《IDEA开发秘籍专栏》学会IDEA常用操作，工作效率翻倍~💐

🌊 《100天精通Golang(基础入门篇）》学会Golang语言，畅玩云原生，走遍大小厂~💐

🪁🍁 希望本文能够给您带来一定的帮助🌸文章粗浅，敬请批评指正！🍁🐥



gRpc的四种通信方式

四种通信方式

  1. 简单rpc 一元rpc (Unary RPC)
  2. 服务端流式RPC (Server Streaming RPC)
  3. 客户端流式RPC (Client Streaming RPC)
  4. 双向流RPC (Bi-directional Stream RPC)

摘要：

本文详细介绍了gRpc的四种主要通信方式，包括简单RPC、服务端流式RPC、客户端流式RPC和双向流式RPC。每种方式都有其特点和应用场景，以及相应的代码实现。

导语：

在分布式系统中，通信是至关重要的。gRpc作为一个高性能、开源和通用的RPC框架，为我们提供了多种通信方式。那么，这些通信方式都有哪些特点和应用场景呢？让我们一起深入了解。

引言：

“通信是连接分布式系统的桥梁，而gRpc则为我们提供了这座桥梁的多种形式。从简单的一对一通信到复杂的双向流通信，gRpc都能为我们提供稳定和高效的解决方案。”

简单RPC(一元RPC)

  1. 第一个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则支持双方的双向通信。了解这些通信方式及其应用场景，可以帮助我们更好地设计和实现分布式系统。

参考资料：

  1. gRpc官方文档：https://grpc.io/docs/
  2. “Mastering gRpc” by Alex Konrad.
  3. “Distributed Systems with gRpc” by Sarah Allen.

原创声明

======= ·

  • 原创作者： 猫头虎

作者wx： [ libin9iOak ]

学习 复习
✔

本文为原创文章，版权归作者所有。未经许可，禁止转载、复制或引用。

作者保证信息真实可靠，但不对准确性和完整性承担责任。

未经许可，禁止商业用途。

如有疑问或建议，请联系作者。

感谢您的支持与尊重。

点击下方名片，加入IT技术核心学习团队。一起探索科技的未来，共同成长。
文章标签：
Go
流计算
物联网
Cloud Native
传感器
猫头虎
目录
相关文章
易立
|
Kubernetes 关系型数据库 容器
Kubernetes之路 3 - 解决服务依赖
在容器服务的客户群中，一个经常被问起的问题就是如何处理服务间依赖。本文介绍了常见的解决方法来实现服务的依赖检查，还进一步用示例展示了如何利用init container， liveness/readiness探针等技术实现服务健康检查，依赖检查等等功能。
易立
12331 1
mikechen优知
|
JavaScript NoSQL Java
高并发架构系列：Redis为什么是单线程、及高并发快的3大原因详解
Redis的高并发和快速原因 1.redis是基于内存的，内存的读写速度非常快；2.redis是单线程的，省去了很多上下文切换线程的时间；3.redis使用多路复用技术，可以处理并发的连接。非阻塞IO 内部实现采用epoll，采用了epoll+自己实现的简单的事件框架。
mikechen优知
4870 0
最好zzz
|
监控 NoSQL 算法
Redis主从切换，锁失效怎么办？
在分布式系统中，Redis因其高性能和易用性而被广泛应用于缓存、分布式锁等场景。然而，当Redis采用主从架构以实现高可用性和数据冗余时，主从切换可能带来的锁失效问题成为了一个不容忽视的挑战。本文将深入探讨Redis主从切换导致锁失效的原因、影响及解决方案，旨在为大家提供实用的技术干货。
最好zzz
658 5
ike潮
|
缓存 JSON 负载均衡
http请求grpc服务的最终解决方案
所有的rpc协议遵守着一个万变不离其宗的定律：调用方与服务提供方有一套约定的报文解析格式。nodejs做代理，http报文组装成grpc报文，必须依赖.proto文件中定义的消息体
ike潮
2339 0
http请求grpc服务的最终解决方案
ALex_zry
|
存储 C++
gRPC 四模式之 双向流RPC模式
gRPC 四模式之 双向流RPC模式
ALex_zry
1146 0
源码星辰
|
传感器 存储 物联网
物联网的定义和原理
物联网 (IoT) 是指由嵌入传感器、软件和网络连接的物理设备、车辆、电器和其他物理对象组成的网络，允许它们收集和共享数据。这些设备(也称为“智能对象”)的范围可以从简单的“智能家居”设备(如智能恒温器)到可穿戴设备(如智能手表和支持RFID的服装)，再到复杂的工业机械和运输系统。技术人员甚至设想了基于物联网技术的整个“智慧城市”。
源码星辰
2267 1
wljslmz
|
存储 分布式计算 负载均衡
什么是 HBase？其组件起什么作用？
【8月更文挑战第12天】
wljslmz
1896 4
长梦
|
安全 Go 开发者
Golang深入浅出之-Go语言中的CSP模型：深入理解并发哲学
【5月更文挑战第1天】Go语言基于CSP理论，借助goroutines和channels实现独特的并发模型。Goroutine是轻量级线程，通过`go`关键字启动，而channels提供安全的通信机制。文章讨论了数据竞争、死锁和goroutine泄漏等问题及其避免方法，并提供了一个生产者消费者模型的代码示例。理解CSP和妥善处理并发问题对于编写高效、可靠的Go程序至关重要。
长梦
518 2
飞川001
|
存储 Java Go
Go 语言切片如何扩容？（全面解析原理和过程）
Go 语言切片如何扩容？（全面解析原理和过程）
飞川001
845 2
林钟一
|
网络协议 大数据 Go
gRPC（四）基础：gRPC流
Client发送完成后需要手动调用Close()或者CloseSend()方法关闭stream，Server端则return nil就会自动 Close。
林钟一
1680 0
gRPC（四）基础：gRPC流