grpc java一元异步调用实现

要实现gRPC Java的一元异步调用，可以按照以下步骤操作：

1. 定义.proto文件，包括服务名称和方法名称等信息。

2. 使用Protocol Buffer编译器生成Java代码。

3. 实现服务接口，该接口应该继承自proto中定义的服务接口。

4. 实现服务实现类，即服务接口的具体实现。

5. 使用gRPC框架提供的ServerBuilder创建服务端实例。

6. 启动服务端。

7. 在客户端使用gRPC框架提供的Stub对象调用远程方法。

下面是一个简单的示例代码，演示了如何实现一元异步调用：

定义.proto文件：

syntax = "proto3";

package com.example.grpc;

option java_package = "com.example.grpc";
option java_outer_classname = "HelloWorldProto";

service HelloWorld {
    rpc sayHello (HelloRequest) returns (HelloResponse) {}
}

message HelloRequest {
    string name = 1;
}

message HelloResponse {
    string message = 1;
}

生成Java代码：

使用Protocol Buffer编译器生成Java代码，命令如下：

protoc --proto_path=./src/main/proto --java_out=./src/main/java ./src/main/proto/helloworld.proto

实现服务接口：

package com.example.grpc;

import io.grpc.stub.StreamObserver;

public interface HelloWorldServiceGrpc {

    void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver);
}

实现服务实现类：

package com.example.grpc;

import io.grpc.stub.StreamObserver;

public class HelloWorldServiceImpl extends HelloWorldServiceGrpc.HelloWorldServiceImplBase {

    @Override
    public void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver) {
        HelloResponse response = HelloResponse.newBuilder()
                .setMessage("Hello " + request.getName())
                .build();
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

创建服务端实例并启动：

package com.example.grpc;

import io.grpc.Server;
import io.grpc.ServerBuilder;

import java.io.IOException;

public class HelloWorldServer {

    private final int port;
    private final Server server;

    public HelloWorldServer(int port) {
        this.port = port;
        this.server = ServerBuilder.forPort(port)
                .addService(new HelloWorldServiceImpl())
                .build();
    }

    public void start() throws IOException {
        server.start();
        System.out.println("Server started, listening on " + port);
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.err.println("*** shutting down gRPC server since JVM is shutting down");
            HelloWorldServer.this.stop();
            System.err.println("*** server shut down");
        }));
    }

    public void stop() {
        if (server != null) {
            server.shutdown();
        }
    }

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

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

客户端调用：

package com.example.grpc;

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.stub.StreamObserver;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class HelloWorldClient {

    private final ManagedChannel channel;
    private final HelloWorldServiceGrpc.HelloWorldServiceStub stub;

    public HelloWorldClient(String host, int port) {
        channel = ManagedChannelBuilder.forAddress(host, port)
                .usePlaintext()
                .build();
        stub = HelloWorldServiceGrpc.newStub(channel);
    }

    public void sayHello(String name) throws InterruptedException {
        final CountDownLatch finishLatch = new CountDownLatch(1);
        StreamObserver<HelloResponse> responseObserver = new StreamObserver<HelloResponse>() {
            @Override
            public void onNext(HelloResponse response) {
                System.out.println(response.getMessage());
            }

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

            @Override
            public void onCompleted() {
                finishLatch.countDown();
            }
        };
        HelloRequest request = HelloRequest.newBuilder()
                .setName(name)
                .build();
        stub.sayHello(request, responseObserver);
        finishLatch.await(1, TimeUnit.SECONDS);
    }

    public void shutdown() throws InterruptedException {
        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
    }

    public static void main(String[] args) throws InterruptedException {
        HelloWorldClient client = new HelloWorldClient("localhost", 50051);
        try {
            client.sayHello("World");
        } finally {
            client.shutdown();
        }
    }
}

以上代码演示了如何实现gRPC Java的一元异步调用。