开发易忽视的问题：grpc接口设计与实现

三年之约
559 阅读8分钟

Java gRPC（Google Remote Procedure Call）是一个高性能、开源和通用的RPC框架，基于HTTP/2协议设计，用于构建跨语言的服务。其实现原理可以从以下几个方面进行解释：

  1. 协议缓冲区（Protocol Buffers）：

    • gRPC使用Protocol Buffers作为接口描述语言（IDL）来定义服务端点和消息格式。开发者在.proto文件中定义服务及其方法，这些文件随后会被编译生成相应的客户端和服务端代码。

  2. HTTP/2：

    • gRPC利用HTTP/2的特性，如多路复用、头部压缩、双向流等，提供了更高效的网络通信能力。这使得gRPC在性能和带宽利用方面优于传统的HTTP/1.x。

  3. 服务端和客户端：

    • 在服务端，gRPC自动生成的代码包括一个抽象类，你需要继承这个抽象类并实现服务方法。
    • 在客户端，gRPC提供自动生成的存根（stub），用于调用远程服务的方法。客户端通过这些存根发送请求并接收响应。

  4. 拦截器机制：

    • gRPC支持在客户端和服务端添加拦截器，用于在请求和响应过程中执行自定义逻辑，例如日志记录、认证授权等。

  5. 负载均衡和名称解析：

    • gRPC支持多种负载均衡策略和服务发现机制，可以无缝集成到现代微服务架构中。

  6. 流式处理：

    • gRPC支持四种类型的服务方法：简单模式（Unary RPC）、服务器流模式、客户端流模式和双向流模式。这为实现复杂的通信模式提供了灵活性。

  7. 安全性：

    • gRPC内置支持SSL/TLS加密传输，并且可以扩展以支持其他安全认证机制。

使用步骤

Java中设计和实现gRPC接口通常包括以下几个步骤：

1. 定义服务

首先，使用Protocol Buffers定义服务和消息格式。在.proto文件中，你需要定义服务及其方法。每个方法指定请求和响应的消息类型。

例如，一个简单的服务定义可能如下：

syntax = "proto3";

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

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

2. 使用protoc编译.proto文件

使用Protocol Buffers编译器protoc生成Java代码。你需要设置protoc的路径并执行命令：

protoc --java_out=src/main/java --grpc-java_out=src/main/java -I=. hello.proto

3. 实现服务

生成的Java代码会包含一个抽象类，需要你去实现具体的逻辑。

import io.grpc.stub.StreamObserver;

public class GreeterImpl extends GreeterGrpc.GreeterImplBase {
    @Override
    public void sayHello(HelloRequest req, StreamObserver<HelloResponse> responseObserver) {
        String greeting = "Hello, " + req.getName();
        HelloResponse response = HelloResponse.newBuilder().setMessage(greeting).build();
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

4. 启动gRPC服务器

创建一个gRPC服务器实例，并将实现的服务添加进去，然后启动服务器。

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

import java.io.IOException;

public class GrpcServer {
    private Server server;

    private void start() throws IOException {
        int port = 50051;
        server = ServerBuilder.forPort(port)
            .addService(new GreeterImpl())
            .build()
            .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");
            GrpcServer.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 IOException, InterruptedException {
        final GrpcServer server = new GrpcServer();
        server.start();
        server.blockUntilShutdown();
    }
}

5. 创建客户端

使用生成的存根（stub）来调用远程服务。

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;

public class GrpcClient {
    private final GreeterGrpc.GreeterBlockingStub blockingStub;

    public GrpcClient(String host, int port) {
        ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port)
            .usePlaintext()
            .build();
        blockingStub = GreeterGrpc.newBlockingStub(channel);
    }

    public void greet(String name) {
        HelloRequest request = HelloRequest.newBuilder().setName(name).build();
        HelloResponse response = blockingStub.sayHello(request);
        System.out.println("Greeting: " + response.getMessage());
    }

    public static void main(String[] args) {
        GrpcClient client = new GrpcClient("localhost", 50051);
        client.greet("world");
    }
}

protoc编译器执行流程

protoc是Protocol Buffers的编译器，用于将.proto文件转换为特定编程语言的代码，如Java、C++、Python等。它的工作过程大致如下：

  1. 解析.proto文件：

    • 词法分析：protoc 首先对输入的 .proto 文件进行词法分析，将文本转换为一系列标记（tokens）。
    • 语法分析：接着，利用这些标记构建抽象语法树（AST），表示文件中的语法结构。
    • 验证和检查：在解析过程中，protoc 检查文件的合法性，包括字段编号的唯一性、类型的正确性等。

  2. 生成中间表示：

    • protoc 将语法树转化为一种中间表示，这种表示是与目标语言无关的。
    • 该中间表示包括所有必要的信息，如消息类型、服务定义、枚举和选项等。

  3. 代码生成：

    • 根据中间表示，protoc利用插件机制生成目标语言的代码。对于Java，使用的是--java_out选项。
    • 插件会根据不同语言的特性生成相应的类、方法以及数据结构。在Java中，通常会为每个消息类型生成一个Java类，并为gRPC服务生成存根（stub）代码。

  4. 输出目标代码：

    • 最终，protoc将生成的代码写入指定的输出目录中，这些代码包含用于序列化、反序列化和通信的类或接口。可以在Java项目中直接使用这些代码。

例如，当你运行命令：

protoc --java_out=src/main/java --grpc-java_out=src/main/java -I=. hello.proto
  • --java_out=src/main/java指示protoc生成Java类代码并输出到src/main/java目录。
  • --grpc-java_out=src/main/java用于生成gRPC相关的Java代码，包括服务存根。
  • -I=.指定.proto文件的搜索路径。

通过这些步骤，protoc将定义在.proto文件中的结构转化为Java代码，使得能够在Java应用中方便地使用Protocol Buffers序列化和反序列化数据，以及调用gRPC服务。

grpc生成代码分析

案例：简单的用户信息服务

1. 创建.proto文件

首先，我们定义一个简单的Protocol Buffers文件user.proto，用于描述一个用户信息服务：

syntax = "proto3";

option java_package = "com.example.user";
option java_outer_classname = "UserProto";

service UserService {
  rpc GetUser (UserRequest) returns (UserResponse);
}

message UserRequest {
  int32 id = 1;
}

message UserResponse {
  int32 id = 1;
  string name = 2;
  string email = 3;
}

2. 编译.proto文件

使用protoc编译这个文件，以生成Java类：

protoc --java_out=src/main/java --grpc-java_out=src/main/java -I=. user.proto

3. protoc编译过程

  • 解析和验证：

    • 首先，protoc读取user.proto文件。它解析协议缓冲区的语法结构，例如消息类型、字段及其标签、服务及其方法等。
    • 在解析过程中，protoc会验证语法正确性，比如确保字段编号唯一，并遵循Protocol Buffers的规范。

  • 生成中间表示：

    • 解析完成后，protoc创建内存中的中间表示。这个表示包含所有定义的信息，包括消息结构、字段属性、服务方法等。这是抽象语法树（AST）的一种形式，用于支持跨语言的代码生成。

  • 调用代码生成插件：

    • 对于Java，protoc使用内置的Java代码生成插件。这个插件负责将中间表示转化为Java类。
    • 它为每个消息生成一个Java类，其中包含了用于序列化和反序列化的方法。
    • 针对gRPC服务，它会生成接口和存根类，用于客户端和服务端实现。

  • 写入目标文件：

    • 最终，生成的Java代码被写入指定目录。在我们的例子中，src/main/java下会有两个主要部分：

      • UserProto.java：包含所有消息类型的Java类。
      • UserServiceGrpc.java：包含gRPC相关的类，如服务抽象类、客户端存根等。

4. 生成代码示例

生成的Java代码可能类似于以下结构：

  • UserProto.java 中定义了请求和响应消息类：
public final class UserProto {
  public static final class UserRequest extends com.google.protobuf.GeneratedMessageV3 {
    private int id;
    // getter, setter, and other utility methods...
  }

  public static final class UserResponse extends com.google.protobuf.GeneratedMessageV3 {
    private int id;
    private String name;
    private String email;
    // getter, setter, and other utility methods...
  }
}
  • UserServiceGrpc.java 包含gRPC服务的接口与存根：
public final class UserServiceGrpc {
  public static abstract class UserServiceImplBase implements io.grpc.BindableService {
    public void getUser(UserProto.UserRequest request,
        io.grpc.stub.StreamObserver<UserProto.UserResponse> responseObserver) {
      // Implement service logic here...
    }
  }

  public static final class UserServiceStub extends io.grpc.stub.AbstractStub<UserServiceStub> {
    public void getUser(UserProto.UserRequest request,
        io.grpc.stub.StreamObserver<UserProto.UserResponse> responseObserver) {
      // Client call implementation...
    }
  }
}

UserServiceGrpc 类结构

1. 抽象基类：UserServiceImplBase

  • 目的：为服务器实现提供一个基础框架。

  • 结构：

    • 每个在 .proto 中定义的方法都会在这个类中有一个对应的抽象方法。服务器需要继承这个类并实现这些方法。

    • 例如，对于 GetUser 方法，这里会有一个类似如下的方法：

      public static abstract class UserServiceImplBase implements io.grpc.BindableService {
    public void getUser(UserProto.UserRequest request,
                        io.grpc.stub.StreamObserver<UserProto.UserResponse> responseObserver) {
        // 在此处实现业务逻辑
    }

    @Override
    public final io.grpc.ServerServiceDefinition bindService() {
        return io.grpc.ServerServiceDefinition.builder(SERVICE_NAME)
            .addMethod(
                METHOD_GET_USER,
                asyncUnaryCall(
                    new MethodHandlers<
                        UserProto.UserRequest,
                        UserProto.UserResponse>(
                        this, METHODID_GET_USER)))
            .build();
    }
}

  • 用法：开发者需要创建一个类继承 UserServiceImplBase 并实现 getUser 方法，以处理来自客户端的请求。

2. 客户端存根：UserServiceStub 和 UserServiceBlockingStub

  • 目的：提供与服务器进行通信的接口，实现客户端调用。

  • 结构：

    • UserServiceStub：用于异步调用服务方法。

    • UserServiceBlockingStub：用于同步调用服务方法。

    • 两个存根都包含了与 .proto 文件中定义的每个服务方法对应的 Java 方法。

    • 示例代码：

      public static final class UserServiceStub extends io.grpc.stub.AbstractAsyncStub<UserServiceStub> {
    private UserServiceStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
        super(channel, callOptions);
    }

    public void getUser(UserProto.UserRequest request,
                        io.grpc.stub.StreamObserver<UserProto.UserResponse> responseObserver) {
        asyncUnaryCall(
            getChannel().newCall(METHOD_GET_USER, getCallOptions()), request, responseObserver);
    }
}

public static final class UserServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<UserServiceBlockingStub> {
    private UserServiceBlockingStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
        super(channel, callOptions);
    }

    public UserProto.UserResponse getUser(UserProto.UserRequest request) {
        return blockingUnaryCall(
            getChannel(), METHOD_GET_USER, getCallOptions(), request);
    }
}

  • 用法：客户端通过实例化这些存根并调用相应方法与gRPC服务进行通信。

avatar
文章
阅读
粉丝