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

猫头虎

发布于 2024-04-09 08:43:55

970

发布于 2024-04-09 08:43:55

?? 博主猫头虎带您 Go to New World.?? ? 博客首页——猫头虎的博客? ?《面试题大全专栏》文章图文并茂?生动形象?简单易学！欢迎大家来踩踩~? ? 《IDEA开发秘籍专栏》学会IDEA常用操作，工作效率翻倍~? ? 《100天精通Golang(基础入门篇）》学会Golang语言，畅玩云原生，走遍大小厂~?
?? 希望本文能够给您带来一定的帮助?文章粗浅，敬请批评指正！??

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，并给出了每种方式的特点、使用场景、语法和关键代码。希望对读者有所帮助。