Java gRPC RPC 方法响应的非空保证与异常处理最佳实践

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.StatusRuntimeException;
import io.grpc.Status;

public class MyExampleClient {

    private final MyExampleServiceGrpc.MyExampleServiceBlockingStub blockingStub;

    public MyExampleClient(String host, int port) {
        // 创建一个ManagedChannel来管理与服务器的连接
        ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port)
                .usePlaintext() // 仅用于开发环境，生产环境应使用TLS
                .build();
        blockingStub = MyExampleServiceGrpc.newBlockingStub(channel);

        // 在应用程序关闭时优雅地关闭通道
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.err.println("*** shutting down gRPC channel since JVM is shutting down");
            channel.shutdown();
            System.err.println("*** channel shut down");
        }));
    }

    public void callMyExampleMethod() {
        MyExampleRequest request = MyExampleRequest.newBuilder()
                .setMessage("Hello gRPC")
                .build();
        MyExampleResponse response;

        try {
            // 执行RPC调用
            response = blockingStub.myExampleCall(request);
            // RPC调用成功，处理响应
            System.out.println("Received response: " + response.getResult());

        } catch (StatusRuntimeException e) {
            // 捕获gRPC相关的运行时异常
            Status status = e.getStatus();
            System.err.println("RPC failed: " + status.getCode() + " - " + status.getDescription());

            // 根据状态码进行不同的错误处理
            if (status.getCode() == Status.Code.UNAVAILABLE) {
                System.err.println("Server is unavailable. Please check network connection or server status.");
                // 尝试重试或通知用户
            } else if (status.getCode() == Status.Code.DEADLINE_EXCEEDED) {
                System.err.println("RPC call timed out.");
                // 增加超时时间或优化服务器处理逻辑
            } else if (status.getCode() == Status.Code.INTERNAL) {
                System.err.println("Internal server error. Check server logs.");
                // 记录详细错误信息
            } else {
                System.err.println("Unhandled gRPC error status: " + status.getCode());
            }
            // 可以选择重新抛出异常或进行其他错误恢复操作
            // throw e;

        } catch (Exception e) {
            // 捕获其他非gRPC特定的运行时异常
            System.err.println("An unexpected error occurred: " + e.getMessage());
            e.printStackTrace();
        }
    }

    // 假设MyExampleRequest和MyExampleResponse是Protobuf生成的类
    // 实际项目中需要定义.proto文件并生成
    static class MyExampleRequest {
        private String message;
        public static Builder newBuilder() { return new Builder(); }
        public String getMessage() { return message; }
        static class Builder {
            private MyExampleRequest request = new MyExampleRequest();
            public Builder setMessage(String msg) { request.message = msg; return this; }
            public MyExampleRequest build() { return request; }
        }
    }

    static class MyExampleResponse {
        private String result;
        public static Builder newBuilder() { return new Builder(); }
        public String getResult() { return result; }
        static class Builder {
            private MyExampleResponse response = new MyExampleResponse();
            public Builder setResult(String res) { response.result = res; return this; }
            public MyExampleResponse build() { return response; }
        }
    }

    // 模拟gRPC生成的BlockingStub接口和实现
    static class MyExampleServiceGrpc {
        public static MyExampleServiceBlockingStub newBlockingStub(ManagedChannel channel) {
            return new MyExampleServiceBlockingStub(channel);
        }
        static class MyExampleServiceBlockingStub {
            private final ManagedChannel channel;
            public MyExampleServiceBlockingStub(ManagedChannel channel) { this.channel = channel; }
            public MyExampleResponse myExampleCall(MyExampleRequest request) {
                // 实际gRPC调用逻辑在此处，可能会抛出StatusRuntimeException
                // 模拟成功响应
                if (request.getMessage().contains("error")) {
                    throw new StatusRuntimeException(Status.INTERNAL.withDescription("Simulated server error"));
                }
                if (request.getMessage().contains("timeout")) {
                    throw new StatusRuntimeException(Status.DEADLINE_EXCEEDED.withDescription("Simulated timeout"));
                }
                return MyExampleResponse.newBuilder().setResult("Response for: " + request.getMessage()).build();
            }
        }
    }

    public static void main(String[] args) {
        MyExampleClient client = new MyExampleClient("localhost", 50051);
        System.out.println("--- Successful Call ---");
        client.callMyExampleMethod(); // 模拟成功调用

        System.out.println("\n--- Error Call (Internal) ---");
        client.blockingStub.myExampleCall(MyExampleRequest.newBuilder().setMessage("Contains error").build()); // 模拟服务器内部错误

        System.out.println("\n--- Error Call (Timeout) ---");
        client.blockingStub.myExampleCall(MyExampleRequest.newBuilder().setMessage("Contains timeout").build()); // 模拟超时
    }
}