Java学习第九十四部分——gRPC

发布于：2025-08-03 ⋅ 阅读:(16) ⋅ 点赞:(0)

目录

一、前言提要简介

二、核心概念特点

三、工作原理简述

四、优势适用场景

五、劣势以及考量

六、简单代码示例

七、总结归纳概述

一、前言提要简介

       gRPC（gRPC Remote Procedure Calls）是一个由Google开发的高性能、开源的远程过程调用（RPC）框架，旨在简化分布式系统和服务之间的通信。它基于现代技术栈构建，具有强大的功能和广泛的跨语言支持。

二、核心概念特点

1.  基于 HTTP/2
        这是 gRPC 高性能的关键。HTTP/2 提供了：

  • 二进制协议： 比 HTTP/1.x 的文本协议更高效，解析更快。

  • 多路复用： 在单个 TCP 连接上同时发送多个请求和响应，避免了队头阻塞，极大提高了连接利用率。

  • 头部压缩： 使用 HPACK 压缩减少开销。

  • 服务器推送： 服务器可以主动向客户端推送数据（gRPC 利用此特性实现服务器流）。

2.  使用 Protocol Buffers

  • gRPC ：默认使用 Protocol Buffers 作为其接口定义语言和数据序列化机制。

  • IDL： 你需要在一个 `.proto` 文件中定义你的服务接口（方法名、参数、返回类型）和消息结构（请求和响应的数据结构）。

  • 代码生成： Protobuf 编译器 (`protoc`) 可以基于 `.proto` 文件生成多种编程语言的客户端和服务端代码，极大地简化了开发。

  • 高效序列化： Protobuf 序列化后的数据体积小、速度快，比 JSON/XML 更高效。

3.  强类型和代码生成

  • 通过 `.proto` 文件定义的接口是强类型的。

  • 自动生成的代码确保了客户端和服务端使用一致的数据结构和接口，减少了手动编写样板代码和序列化/反序列化逻辑的错误。

4.  跨语言支持

  • gRPC 支持多种主流编程语言，包括 C++, C#, Dart, Go, Java, Kotlin/JVM, Node.js, Objective-C, PHP, Python, Ruby。这使得用不同语言编写的服务可以轻松相互通信。

5.  四种服务方法

  • Unary RPC： 最像传统的函数调用。客户端发送一个请求，服务器处理并返回一个响应。

  • Server streaming RPC： 客户端发送一个请求，服务器返回一个包含多个响应的流（例如，发送实时股票报价或大型数据集的分块）。

  • Client streaming RPC： 客户端发送一个包含多个请求的流，服务器读取后返回一个响应（例如，客户端上传一个非常大的文件）。

  • Bidirectional streaming RPC： 双方都使用读写流独立发送一系列消息（例如，聊天应用、实时游戏交互）。消息在流中的顺序是保 存的。

6.  内置特性

  • 认证： 支持强大的基于 SSL/TLS 的认证，以及基于 Token 的认证（如 OAuth2, JWT）。

  • 取消和超时： 客户端可以设置 RPC 的超时时间，也可以在服务器处理完成前取消调用。

  • 负载均衡： 在客户端支持多种负载均衡策略。

  • 健康检查： 标准化的健康检查协议，供负载均衡器或编排系统检查服务状态。

  • 拦截器： 提供钩子（Hook）机制，允许在 RPC 调用前后注入自定义逻辑（如日志记录、认证、监控）。

三、工作原理简述

  1. 定义服务接口： 在 `.proto` 文件中定义服务方法和消息格式。

  2. 生成代码： 使用 `protoc` 编译器（配合对应语言的 gRPC 插件）生成服务端骨架代码和客户端存根代码。

  3. 实现服务端： 在服务端，实现生成的接口定义，填充具体的业务逻辑。

  4. 运行服务端： 启动 gRPC 服务器，监听指定端口。

  5. 创建客户端： 在客户端，使用生成的存根调用远程方法，就像调用本地方法一样。

  6. 通信： 客户端存根将请求参数序列化为 Protobuf 格式，通过 HTTP/2 发送给服务端。服务端接收请求，反序列化参数，调用实现逻辑，将响应序列化后通过 HTTP/2 返回给客户端。客户端存根再将响应反序列化，返回给调用方。

四、优势适用场景

  • 高性能： HTTP/2 + Protobuf 的组合带来了显著的性能提升（速度更快、延迟更低、带宽占用更少）。

  • 高效开发： 强类型接口定义和代码生成减少了错误，加速了开发进程。

  • 强契约： `.proto` 文件作为明确的、语言无关的服务契约。

  • 流处理： 内置支持强大的流式处理，非常适合实时场景和大数据传输。

  • 跨语言： 无缝连接不同技术栈的服务。

  • 丰富的生态系统： 围绕 gRPC 有大量工具和库（如 grpc-gateway 用于生成 RESTful JSON APIs）。

  • 云原生友好： 是构建微服务、云原生应用的理想选择，天然支持负载均衡、健康检查等。

五、劣势以及考量

  • 浏览器支持受限： 原生 gRPC 在 Web 浏览器中支持不完善（主要因为浏览器对 HTTP/2 的低级 API 访问受限）。通常需要使用 grpc-web 代理或 gRPC-Gateway 将 gRPC 服务暴露为 REST/JSON。

  • 可调试性： 二进制 Protobuf 格式不像 JSON 那样直接可读，调试时需要额外的工具（如 `grpcurl`）。

  • 学习曲线： 需要理解 Protobuf、HTTP/2 和 gRPC 自身的概念。

  • 非文本格式： 对于需要人类直接阅读或编辑消息的场景不如 JSON/XML 方便。

六、简单代码示例

以下是一个使用 Java 实现的 gRPC 示例代码，包含服务定义、服务端实现和客户端调用：

1. 添加 Maven 依赖 (`pom.xml`)

<dependencies>
    <!-- gRPC 核心库 -->
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-netty-shaded</artifactId>
        <version>1.59.0</version>
    </dependency>
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-protobuf</artifactId>
        <version>1.59.0</version>
    </dependency>
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-stub</artifactId>
        <version>1.59.0</version>
    </dependency>
    
    <!-- 代码生成插件 -->
    <dependency>
        <groupId>com.google.protobuf</groupId>
        <artifactId>protobuf-java</artifactId>
        <version>3.25.1</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <!-- Protobuf 代码生成插件 -->
        <plugin>
            <groupId>org.xolstice.maven.plugins</groupId>
            <artifactId>protobuf-maven-plugin</artifactId>
            <version>0.6.1</version>
            <configuration>
                <protocArtifact>com.google.protobuf:protoc:3.25.1:exe:${os.detected.classifier}</protocArtifact>
                <pluginId>grpc-java</pluginId>
                <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.59.0:exe:${os.detected.classifier}</pluginArtifact>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <goal>compile-custom</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        
        <!-- 检测操作系统 -->
        <plugin>
            <groupId>kr.motd.maven</groupId>
            <artifactId>os-maven-plugin</artifactId>
            <version>1.7.1</version>
        </plugin>
    </plugins>
</build>

2. 定义服务 (`src/main/proto/greeter.proto`)

syntax = "proto3";

option java_multiple_files = true;
option java_package = "com.example.grpc";
option java_outer_classname = "GreeterProto";

package greeter;

// 服务定义
service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// 请求消息
message HelloRequest {
  string name = 1;
}

// 响应消息
message HelloReply {
  string message = 1;
}

3. 服务端实现 (`src/main/java/com/example/grpc/GreeterServer.java`)

package com.example.grpc;

import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.stub.StreamObserver;
import java.io.IOException;

public class GreeterServer {
    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");
            GreeterServer.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();
        }
    }

    // 服务实现
    static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
        @Override
        public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
            // 构建响应
            HelloReply reply = HelloReply.newBuilder()
                    .setMessage("Hello " + req.getName() + "! (from Java gRPC server)")
                    .build();
            
            // 发送响应
            responseObserver.onNext(reply);
            // 完成调用
            responseObserver.onCompleted();
            
            System.out.println("Request handled: " + req.getName());
        }
    }

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

4. 客户端实现 (`src/main/java/com/example/grpc/GreeterClient.java`

package com.example.grpc;

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import java.util.concurrent.TimeUnit;

public class GreeterClient {
    private final ManagedChannel channel;
    private final GreeterGrpc.GreeterBlockingStub blockingStub;

    // 初始化通道和存根
    public GreeterClient(String host, int port) {
        this.channel = ManagedChannelBuilder.forAddress(host, port)
                .usePlaintext() // 仅用于测试，生产环境需加密
                .build();
        this.blockingStub = GreeterGrpc.newBlockingStub(channel);
    }

    // 关闭通道
    public void shutdown() throws InterruptedException {
        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
    }

    // 调用服务
    public void greet(String name) {
        // 构建请求
        HelloRequest request = HelloRequest.newBuilder().setName(name).build();
        
        // 发送请求并获取响应
        HelloReply response = blockingStub.sayHello(request);
        
        System.out.println("Response received: " + response.getMessage());
    }

    public static void main(String[] args) throws InterruptedException {
        GreeterClient client = new GreeterClient("localhost", 50051);
        try {
            client.greet("Java Client");
        } finally {
            client.shutdown();
        }
    }
}

5.使用说明

1. 代码生成
   mvn compile
   这会根据 `.proto` 文件生成 Java 代码到 `target/generated-sources/protobuf`

2. 启动服务端
   mvn exec:java -Dexec.mainClass="com.example.grpc.GreeterServer"
   输出: `Server started, listening on 50051`

3. 运行客户端
   mvn exec:java -Dexec.mainClass="com.example.grpc.GreeterClient"
   输出: `Response received: Hello Java Client! (from Java gRPC server)`

6.关键组件说明

1. 服务定义 (proto文件)
   - 使用 Protocol Buffers 语法定义服务和消息格式
   - 编译后生成 `GreeterGrpc` 和消息类

2. 服务端
   - 继承 `GreeterGrpc.GreeterImplBase` 实现业务逻辑
   - 使用 `ServerBuilder` 创建 gRPC 服务器
   - 处理请求并通过 `StreamObserver` 发送响应

3. 客户端
   - 使用 `ManagedChannel` 创建到服务端的连接
   - 通过 `GreeterGrpc.newBlockingStub()` 创建存根(stub)
   - 像调用本地方法一样调用远程服务

4. 通信流程

   sequenceDiagram
       participant Client
       participant Server
       Client->>Server: HelloRequest(name="Java Client")
       Server->>Client: HelloReply(message="Hello...")

ps: 此示例使用明文通信(`usePlaintext()`)，仅适用于开发和测试环境。生产环境应使用 TLS 加密:

.useTransportSecurity(new File("server.crt"), new File("server.key"))

七、总结归纳概述

  • gRPC 是一个现代化、高性能、跨语言的 RPC 框架，特别适合构建高效的分布式系统和微服务架构。

  • gRPC通过利用 HTTP/2 和 Protocol Buffers 解决了传统 REST/JSON API 在性能和开发效率上的诸多痛点。尽管在浏览器直接支持和调试便利性上存在挑战，但其强大的功能、清晰的契约定义和广泛的生态系统使其成为云原生时代服务间通信的主流选择之一。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布