grpc-java代码实战

最新推荐文章于 2026-07-05 16:09:59 发布

原创最新推荐文章于 2026-07-05 16:09:59 发布 · 974 阅读

2 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

grpc

源码地址

下面将的所有demo都放到了git上。可以结合demo学习。
链接: 源码地址.

maven 环境搭建

通过maven引入grpc相关包

 <dependencies>
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>3.9.1</version>
        </dependency>
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java-util</artifactId>
            <version>3.9.1</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-netty</artifactId>
            <version>${grpc.version}</version>

        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-protobuf</artifactId>
            <version>${grpc.version}</version>

        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-stub</artifactId>
            <version>${grpc.version}</version>
        </dependency>
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>${protobuf.version}</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.0</version>
                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

建立proto文件

syntax = "proto3";

option java_multiple_files = true;
option java_package = "hello";
option java_outer_classname = "HelloProto";
option java_generic_services = true;   // 可以生成rpc接口


package hello;

service Hello {
  //一元 RPC 模式
  rpc SayHello (HelloRequest) returns (HelloResponse) ;

  //服务器端流式RPC模式
  rpc serviceStreamHello(HelloRequest) returns (stream HelloResponse);
  //客户端流式RPC模式
  rpc clientStreamHello(stream HelloRequest) returns (HelloResponseList) ;
  //双向流式RPC模式
  rpc clientServiceStreamHello(stream HelloRequest) returns (stream HelloResponse) ;

}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloResponse {
  string message = 1;
}

message HelloResponseList {
  repeated HelloResponse helloResponse = 1;
}

生成 protobuf，点击右侧的plugins->protobuf->protobuf:compile 生成protobuf代码

在这里插入图片描述
生成的代码如下

生成grpc-java代码
生成 protobuf，点击右侧的plugins->protobuf->protobuf:compile-custom 生成java代码

生成代码如下图所示

流实现

public class HelloServer {

    private Server server;

    private void start() throws IOException {
        /* The port on which the server should run */
        int port = 50051;
        server = ServerBuilder.forPort(port)
                .addService(new HelloIml())  //这里可以添加多个模块
                .build()
                .start();
        System.out.println("Server started, listening on " + port);
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                // Use stderr here since the logger may have been reset by its JVM shutdown hook.
                System.err.println("*** shutting down gRPC server since JVM is shutting down");
                try {
                    HelloServer.this.stop();
                } catch (InterruptedException e) {
                    e.printStackTrace(System.err);
                }
                System.err.println("*** server shut down");
            }
        });
    }

    private void stop() throws InterruptedException {
        if (server != null) {
            server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
        }
    }

    private void blockUntilShutdown() throws InterruptedException {
        if (server != null) {
            server.awaitTermination();
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        final HelloServer server = new HelloServer();
        server.start();
        server.blockUntilShutdown();
    }

其中一元流

一元流

客户端

 //一元流 
    public void greet(String name) {
        HelloRequest request = HelloRequest.newBuilder().setName(name).build();
        HelloResponse response = blockingStub.sayHello(request);
        System.out.println(request.getName());
        System.out.println(response.getMessage());
    }

服务端

  private static class HelloIml extends HelloGrpc.HelloImplBase {
        //一元流
        @Override
        public void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver) {
            responseObserver.onNext(HelloResponse.newBuilder().setMessage("服务端:小明好").build());
            responseObserver.onCompleted();
        }
        }

运行

  public static void main(String[] args) throws InterruptedException {
        HelloClient client = new HelloClient("127.0.0.1", 50051);
        client.greet("客户端:小红好");
        }

执行结果
在这里插入图片描述

服务端流

客户端

 //服务流 ok
       public void serviceStream(String name) {
        HelloRequest request = HelloRequest.newBuilder().setName(name).build();

        Iterator<HelloResponse> iterator = blockingStub.serviceStreamHello(request);
        System.out.println(request.getName());
        while (iterator.hasNext()) {//服务端发送了多个流，这里循环接收
            HelloResponse response = iterator.next();
            System.out.println(response.getMessage());
        }
    }

服务端

   public void serviceStream(String name) {
        HelloRequest request = HelloRequest.newBuilder().setName(name).build();

        Iterator<HelloResponse> iterator = blockingStub.serviceStreamHello(request);
        while (iterator.hasNext()) {//服务端发送了多个流，这里循环接收
            HelloResponse response = iterator.next();
            System.out.println(response.getMessage());
        }
    }

执行

 public static void main(String[] args) throws InterruptedException {
        HelloClient client = new HelloClient("127.0.0.1", 50051);

        client.serviceStream("客户端:小红好");
        }

返回结果
服务流返回结果

客户端流

客户端

 //客户流
    public void clientStream(String name) {
        StreamObserver<HelloResponseList> helloResponseList = new StreamObserver<HelloResponseList>() {

            @Override
            public void onNext(HelloResponseList helloResponseList) {
                helloResponseList.getHelloResponseList().forEach(e -> {
                    System.out.println(e.getMessage());
                });
            }

            @Override
            public void onError(Throwable t) {
                System.out.println(t.getMessage());
            }

            @Override
            public void onCompleted() {
                System.out.println("completed!");
            }
        };

        StreamObserver<HelloRequest> helloRequestStreamObserver = stub.clientStreamHello(helloResponseList);
        helloRequestStreamObserver.onNext(HelloRequest.newBuilder().setName("客户端:小红好").build());
        helloRequestStreamObserver.onNext(HelloRequest.newBuilder().setName("客户端:吃饭了吗").build());
        helloRequestStreamObserver.onNext(HelloRequest.newBuilder().setName("客户端:今天出去玩吗").build());
        helloRequestStreamObserver.onCompleted();

        try {
            //因为grpc调用参数为stream的时候，都是采取异步处理，客户端程序不会等待结果响应
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

服务端

  //客户流
        @Override
        public StreamObserver<HelloRequest> clientStreamHello(StreamObserver<HelloResponseList> responseObserver) {

            return new StreamObserver<HelloRequest>() {

                @Override
                public void onNext(HelloRequest helloRequest) {//获取的
                    System.out.println(helloRequest.getName());
                }

                @Override
                public void onError(Throwable throwable) {
                    System.out.println(throwable.getMessage());
                }

                @Override
                public void onCompleted() {
                    HelloResponse helloResponse1 = HelloResponse.newBuilder().setMessage("服务端：你好小华").build();
                    HelloResponse helloResponse2 = HelloResponse.newBuilder().setMessage("服务端:已经吃了").build();
                    HelloResponseList list = HelloResponseList.newBuilder()
                            .addHelloResponse(helloResponse1)
                            .addHelloResponse(helloResponse2)
                            .build();
                    responseObserver.onNext(list);
                    responseObserver.onCompleted();
                }
            };
        }

调用

    public static void main(String[] args) throws InterruptedException {
        HelloClient client = new HelloClient("127.0.0.1", 50051);
        client.clientStream("客户端流参数");
        }

结果

客户端
服务端

双向流

客户端

 //客户服务流
    public void clientServerStream(String name) {

        StreamObserver<HelloResponse> helloResponse = new StreamObserver<HelloResponse>() {
            @Override
            public void onNext(HelloResponse helloResponse) {
                System.out.println(helloResponse.getMessage());
            }

            @Override
            public void onError(Throwable t) {
                System.out.println(t.getMessage());
            }

            @Override
            public void onCompleted() {
                System.out.println("completed!");
            }
        };

        StreamObserver<HelloRequest> helloRequestStreamObserver = stub.clientServiceStreamHello(helloResponse);

        for (int i = 0; i < 10; i++) {
            helloRequestStreamObserver.onNext(HelloRequest.newBuilder().setName(name + i).build());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        try {
            //因为grpc调用参数为stream的时候，都是采取异步处理，客户端程序不会等待结果响应
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

服务端

 //客户服务流
        @Override
        public StreamObserver<HelloRequest> clientServiceStreamHello(StreamObserver<HelloResponse> responseObserver) {
            return new StreamObserver<HelloRequest>() {
                @Override
                public void onNext(HelloRequest helloRequest) {
                    System.out.println("服务端接受：" + helloRequest.getName());
                    responseObserver.onNext(HelloResponse.newBuilder().setMessage("接受到了" + helloRequest.getName()).build());
                }

                @Override
                public void onError(Throwable t) {
                    System.out.println(t.getMessage());
                }

                @Override
                public void onCompleted() {

                    responseObserver.onCompleted();
                }
            };
        }

运行

 public static void main(String[] args) throws InterruptedException {
        HelloClient client = new HelloClient("127.0.0.1", 50051);
      client.clientServerStream("客户服务流参数");
      }