Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

vue 如何调用grpc-web实现通过http2向服务端通信,而不是通过http1

  1. User

    vue 如何调用grpc-web实现通过http2向服务端通信,而不是通过http1

  2. Assistant

    首先需要安装grpc-web:

    npm install grpc-web
    

    接下来,需要创建一个gRPC服务端和一个gRPC客户端。以下是一个简单的例子:

    定义.proto文件:

    syntax = "proto3";
    
    package hello;
    
    service HelloService {
        rpc SayHello(HelloRequest) returns (HelloResponse) {}
    }
    
    message HelloRequest {
        string name = 1;
    }
    
    message HelloResponse {
        string message = 1;
    }
    

    生成.proto文件代码:

    protoc --proto_path=src/ --js_out=import_style=commonjs,binary:src/ --grpc-web_out=import_style=typescript,mode=grpcwebtext:src/ hello.proto
    

    在服务端实现HelloService:

    const grpc = require('grpc');
    const protoLoader = require('@grpc/proto-loader');
    
    const packageDefinition = protoLoader.loadSync('src/hello.proto');
    const helloPackage = grpc.loadPackageDefinition(packageDefinition).hello;
    
    function sayHello(call, callback) {
      const name = call.request.name;
      callback(null, { message: `Hello, ${name}!`});
    }
    
    const server = new grpc.Server();
    server.addService(helloPackage.HelloService.service, {
      sayHello
    });
    
    server.bind(`0.0.0.0:${port}`, grpc.ServerCredentials.createInsecure());
    server.start();
    

    在客户端调用:

    import * as grpcWeb from 'grpc-web';
    import { HelloServiceClient } from './proto/hello_pb_service';
    import { HelloRequest, HelloResponse } from './proto/hello_pb';
    
    const client = new HelloServiceClient('http://localhost:8080');
    
    const request = new HelloRequest();
    request.setName('World');
    
    client.sayHello(request, {}, (err: grpcWeb.Error, response: HelloResponse) => {
      if (err) {
        console.log(`Error: ${err.message}`);
        return;
      }
      console.log(`Response: ${response.getMessage()}`);
    });
    

    需要注意的是,grpc-web只支持部分gRPC特性,例如实时双向流只支持HTTP2 server push,不支持HTTP1。如果需要更高级的特性,可以考虑使用gRPC Node.js实现。

  3. User

    java + grpc如何实现异步通信

  4. Assistant

    在 Java + gRPC 中实现异步通信可通过以下两种方式来实现:

    1. Future 和 Async 风格

    gRPC 可通过让客户端获取 Future 对象,从而在服务端完成 RPC 请求之前允许异步调用。然后,客户端可以等待该返回 Future 对象的请求,以便在服务端完成任务并响应后接收响应。

    使用 gRPC 异步风格还必须在 service 定义文件中声明 FutureHolder 类,这个类会提供通过请求创建 Future 对象的方法,并且会执行相应的调度器。

    定义 protobuf 文件:

    syntax = "proto3";
    
    package async;
    
    service AsyncService {
        rpc doAsync(AsyncRequest) returns (AsyncResponse);
    }
    
    message AsyncRequest {
        string message = 1; 
    }
    
    message AsyncResponse {
        string response = 1;
    }
    

    生成 gRPC 的 Stub 和 AsyncStub:

    protoc async.proto --java_out=./src/main/java/ --grpc-java_out=./src/main/java/ --plugin=protoc-gen-grpc-java=/usr/local/bin/protoc-gen-grpc-java-1.32.1-osx-x86_64.exe
    

    在代码中实现异步调用:

    public class AsyncClient {
        private final ManagedChannel channel;
        private final AsyncServiceGrpc.AsyncServiceFutureStub asyncStub;
    
        public AsyncClient(String host, int port) {
            this(ManagedChannelBuilder.forAddress(host, port).usePlaintext().build());
        }
    
        public AsyncClient(ManagedChannel channel) {
            this.channel = channel;
            asyncStub = AsyncServiceGrpc.newFutureStub(channel);
        }
    
        public CompletableFuture<String> doAsync(String message) {
            AsyncRequest request = AsyncRequest.newBuilder().setMessage(message).build();
            CompletableFuture<String> future = new CompletableFuture<>();
            RpcFuture<AsyncResponse> rpcFuture = asyncStub.doAsync(request);
            rpcFuture.addListener(() -> {
                try {
                    AsyncResponse response = rpcFuture.get();
                    future.complete(response.getResponse());
                } catch (Exception e) {
                    future.completeExceptionally(e);
                }
            }, Runnable::run);
            return future;
        }
    
        public void shutdown() throws InterruptedException {
            channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
        }
    
        public static void main(String[] args) throws Exception {
            AsyncClient client = new AsyncClient("localhost", 50051);
            String message = "This is an async call";
            CompletableFuture<String> future = client.doAsync(message);
            System.out.println(future.get());
            client.shutdown();
        }
    }
    
    1. Server Streaming 和 Client Streaming

    实现 Server Streaming 和 Client Streaming 是一种简单的异步技巧: 对于复杂服务器端RPC,可以使用gRPC Server Streaming和Client Streaming,将通信转换为异步流。Server Streaming 可以由服务器端异步流式传输响应,而 Client Streaming 可以使客户端异步流式传输整个请求消息。

    定义 protobuf 文件:

    syntax = "proto3";
    
    package streaming;
    
    service StreamingService {
        rpc serverStream(StreamingRequest) returns (stream StreamingResponse);
        rpc clientStream(stream StreamingRequest) returns (StreamingResponse);
    }
    
    message StreamingRequest {
        string message = 1; 
    }
    
    message StreamingResponse {
        string response = 1;
    }
    

    生成 gRPC 的 Stub:

    protoc streaming.proto --java_out=./src/main/java/ --grpc-java_out=./src/main/java/ --plugin=protoc-gen-grpc-java=/usr/local/bin/protoc-gen-grpc-java-1.32.1-osx-x86_64.exe
    

    在代码中实现 Server Streaming 和 Client Streaming:

    public class StreamingServer {
        private static final Logger logger = Logger.getLogger(StreamingServer.class.getName());
    
        private final int port;
        private final Server server;
    
        private StreamingServer(int port) throws IOException {
            this.port = port;
            server = ServerBuilder.forPort(port).addService(new StreamingServiceImpl()).build();
        }
    
        private void start() throws IOException {
            server.start();
            logger.info("Server started, listening on " + port);
            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                System.err.println("*** shutting down gRPC server since JVM is shutting down");
                this.stop();
                System.err.println("*** server shut down");
            }));
        }
    
        private void stop() {
            if (server != null) {
                server.shutdown();
            }
        }
    
        private void blockUntilShutdown() throws InterruptedException {
            if (server != null) {
                server.awaitTermination();
            }
        }
    
        public static void main(String[] args) throws Exception {
            StreamingServer server = new StreamingServer(50051);
            server.start();
            server.blockUntilShutdown();
        }
    
        static class StreamingServiceImpl extends StreamingServiceGrpc.StreamingServiceImplBase {
            @Override
            public void serverStream(StreamingRequest request, StreamObserver<StreamingResponse> responseObserver) {
                Executor executor = Executors.newSingleThreadExecutor();
                executor.execute(() -> {
                    try {
                        for (int i = 0; i < 5; i++) {
                            String message = String.format("Server Streaming response %d for message: %s", i, request.getMessage());
                            logger.info(message);
                            StreamingResponse response = StreamingResponse.newBuilder().setResponse(message).build();
                            responseObserver.onNext(response);
                            TimeUnit.SECONDS.sleep(1);
                        }
                        responseObserver.onCompleted();
                    } catch (InterruptedException e) {
                        responseObserver.onError(e);
                    }
                });
            }
    
            @Override
            public StreamObserver<StreamingRequest> clientStream(StreamObserver<StreamingResponse> responseObserver) {
                return new StreamObserver<StreamingRequest>() {
                    private StringBuilder requestCollector = new StringBuilder();
    
                    @Override
                    public void onNext(StreamingRequest request) {
                        requestCollector.append(request.getMessage()).append("; ");
                    }
    
                    @Override
                    public void onError(Throwable throwable) {
                        responseObserver.onError(throwable);
                    }
    
                    @Override
                    public void onCompleted() {
                        String responseMessage = "Client Streaming response received for message: " + requestCollector.toString();
                        StreamingResponse response = StreamingResponse.newBuilder().setResponse(responseMessage).build();
                        responseObserver.onNext(response);
                        responseObserver.onCompleted();
                    }
                };
            }
        }
    }
    

    在代码中调用:

    public class StreamingClient {
        private final ManagedChannel channel;
        private final StreamingServiceGrpc.StreamingServiceStub stub;
    
        public StreamingClient(String host, int port) {
            channel = ManagedChannelBuilder.forAddress(host, port)
                    .usePlaintext()
                    .build();
            stub = StreamingServiceGrpc.newStub(channel);
        }
    
        public void serverStreaming(String message) throws InterruptedException {
            StreamingRequest request = StreamingRequest.newBuilder().setMessage(message).build();
            stub.serverStream(request, new StreamObserver<StreamingResponse>() {
                @Override
                public void onNext(StreamingResponse streamingResponse) {
                    System.out.println("Server Streaming Response: " + streamingResponse.getResponse());
                }
    
                @Override
                public void onError(Throwable throwable) {
                    System.err.println(throwable.getMessage());
                }
    
                @Override
                public void onCompleted() {
                    System.out.println("Server Streaming Completed");
                }
            });
        }
    
        public void clientStreaming(String message) throws InterruptedException {
            CountDownLatch latch = new CountDownLatch(1);
            StreamObserver<StreamingRequest> streamObserver = stub.clientStream(new StreamObserver<StreamingResponse>() {
                @Override
                public void onNext(StreamingResponse streamingResponse) {
                    System.out.println("Client Streaming Response: " + streamingResponse.getResponse());
                }
    
                @Override
                public void onError(Throwable throwable) {
                    System.err.println(throwable.getMessage());
                }
    
                @Override
                public void onCompleted() {
                    System.out.println("Client Streaming Completed");
                    latch.countDown();
                }
            });
    
            try {
                streamObserver.onNext(StreamingRequest.newBuilder().setMessage("Message 1").build());
                streamObserver.onNext(StreamingRequest.newBuilder().setMessage("Message 2").build());
                streamObserver.onNext(StreamingRequest.newBuilder().setMessage("Message 3").build());
                streamObserver.onCompleted();
                latch.await();
            } catch (RuntimeException | InterruptedException e) {
                streamObserver.onError(e);
                throw e;
            }
        }
    
        public void shutdown() throws InterruptedException {
            channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
        }
    
        public static void main(String[] args) throws Exception {
            StreamingClient client = new StreamingClient("localhost", 50051);
            String message = "This is a message";
            client.serverStreaming(message);
            client.clientStreaming(message);
            client.shutdown();
        }
    }
    

    以上就是 Java + gRPC 中实现异步通信的两种方式,通过实现 Future 和 Async 风格以及Server Streaming 和 Client Streaming,gRPC 的 Java 客户端和服务器可以实现异步通信。