vue 如何调用grpc-web实现通过http2向服务端通信,而不是通过http1
- User
vue 如何调用grpc-web实现通过http2向服务端通信,而不是通过http1
- 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实现。
- User
java + grpc如何实现异步通信
- Assistant
在 Java + gRPC 中实现异步通信可通过以下两种方式来实现:
- 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(); } }- 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 客户端和服务器可以实现异步通信。