高性能微服务架构：Spring Boot 集成 gRPC 实现用户与订单服务即时交互

SteveCode.2024-09-21 20:20

gRPC 是一种由 Google 开发的高性能、开源的远程过程调用（Remote Procedure Call, RPC）框架。它允许在不同的计算机系统或进程之间进行通信，使得分布式系统和微服务架构中的服务之间能够轻松地相互调用方法。gRPC 基于 HTTP/2 协议，并使用 Protocol Buffers（Protobuf）作为其接口定义语言和序列化格式。

gRPC 的主要特点和优点：

  1. 跨语言支持 ：

    gRPC 支持多种编程语言，包括 C++, Java, Python, Go, C#, Node.js 等，因此不同语言编写的服务之间可以无缝通信。

  2. 高性能 ：

    gRPC 使用 HTTP/2 协议，这意味着它支持双向流、多路复用和头部压缩，能更高效地利用网络资源，降低延迟。

  3. 协议定义 ：

    gRPC 使用 Protocol Buffers 作为其接口定义语言（IDL）。开发者通过定义 .proto 文件，描述服务和消息结构，gRPC 工具可以自动生成对应语言的客户端和服务器端代码。

  4. 简单易用 ：

    gRPC 提供了一套简洁的 API，开发者可以轻松创建和调用远程服务，就像调用本地方法一样。

  5. 双向流和流控 ：

    gRPC 不仅支持传统的一次性请求-响应模型，还支持双向流，使得客户端和服务器之间可以发送多个消息，并且这些消息可以并行地传输和处理。

  6. 安全性 ：

    gRPC 原生支持 SSL/TLS，可以很容易地实现安全的通信。

gRPC 的应用场景：

  1. 微服务架构 ：

    在微服务架构中，服务之间需要进行大量的通信，gRPC 提供了高效、跨语言的解决方案，适用于需要低延迟和高吞吐量的应用。

  2. 分布式系统 ：

    在分布式系统中，多个节点之间可能需要频繁通信，gRPC 的高性能和双向流支持非常适合这种场景。

  3. 实时通信 ：

    gRPC 的双向流特性使其非常适合需要实时数据交换的应用，例如实时聊天、视频流、物联网（IoT）应用等。

  4. 跨平台服务 ：

    由于 gRPC 支持多种语言和平台，它非常适合构建跨平台的分布式服务。

总结来说，gRPC 是一种高效、灵活的远程调用框架，特别适合需要跨语言、高性能通信的分布式系统和微服务架构。

一个常见的 gRPC 使用实例是在微服务架构中，尤其是像 Uber 这样的公司，它们拥有多个微服务，需要在不同的服务之间进行高效、低延迟的通信。

需求：用户服务和订单服务的通信

假设有一个电商平台，它的系统由多个微服务组成，其中包括：

  1. 用户服务（User Service）：管理用户信息，如注册、登录、个人资料等。
  2. 订单服务（Order Service）：处理用户的订单信息，如创建订单、查询订单状态等。
  3. grpc-api：将 gRPC 的 Protobuf 定义提取到一个独立的 grpc-api 模块中，其他微服务（如用户服务和订单服务）可以引用该模块，共享 gRPC 定义和生成的代码。

用户在下订单时，订单服务需要验证用户的身份，并获取用户的相关信息（如地址、支付方式等）。在这种情况下，订单服务需要调用用户服务来获取这些信息。

模块的目录结构

├─grpc-api
│  └─src
│      └─main
│          ├─java
│          │  └─com
│          │      └─song
│          │          └─api
│          ├─proto
│          └─resources
├─grpc-order
│  └─src
│      └─main
│          ├─java
│          │  └─com
│          │      └─song
│          │          ├─service
│          │          └─web
│          └─resources
└─grpc-user
    └─src
        └─main
            ├─java
            │  └─com
            │      └─song
            │          └─service
            └─resources

1. 创建 grpc-api 模块

创建一个 Maven 项目 grpc-api，用于存放 .proto 文件和生成的 gRPC Java 代码。这个模块将被其他服务（如用户服务和订单服务）依赖。

2. 在 grpc-api 模块中定义 .proto 文件

在 grpc-api 模块的 src/main/proto/ 目录下创建 .proto 文件，例如：

proto 复制代码 
syntax = "proto3";

package com.song.api;
// 创建一个rpc 服务
service UserService {
  rpc GetUserInfo (GetUserInfoRequest) returns (GetUserInfoResponse);
}
//方法的入参请求对象与入参 。参数必须有唯一标识并还是有顺序的
message GetUserInfoRequest {
  string user_id = 1;
}
//方法的响应请求对象与响应参数 。参数必须有唯一标识并还是有顺序的
message GetUserInfoResponse {
  string name = 1;
  string email = 2;
  string address = 3;
}

3. 配置 grpc-api 模块的 pom.xml

在 grpc-api 模块的 pom.xml 中，配置 gRPC 和 Protobuf 相关的依赖和插件，以便自动生成 gRPC 代码。

xml 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>yqmm-grpc</artifactId>
        <groupId>com.song</groupId>
        <version>1.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>grpc-api</artifactId>
    <description>grpc公共api提取</description>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <grpc-version>1.40.1</grpc-version>
        <protobuf-version>3.21.9</protobuf-version>
    </properties>

    <dependencies>
        <!-- gRPC 依赖 -->
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-all</artifactId>
            <version>${grpc-version}</version>
        </dependency>

        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>${protobuf-version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.google.protobuf/protoc -->
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protoc</artifactId>
            <version>${protobuf-version}</version>
            <type>pom</type>
        </dependency>
    </dependencies>

    <build>
        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
            </extension>
        </extensions>
        <plugins>
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.6.1</version>
                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:3.19.1:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.50.2:exe:${os.detected.classifier}</pluginArtifact>
                    <!-- 设置输出目录 -->
                    <outputDirectory>${project.basedir}/src/main/java</outputDirectory>
                    <!-- 设置proto文件所在目录 -->
                    <protoSourceRoot>${project.basedir}/src/main/proto</protoSourceRoot>
                    <!-- 是否清除输出目录 -->
                    <clearOutputDirectory>false</clearOutputDirectory>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <layout>NONE</layout>
                    <skip>true</skip>           <!--    自己打出的包也能用 ,就是打出的包不包含BOOT-INF目录        -->
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

4. 生成 gRPC 代码

在 grpc-api 模块根目录下运行以下命令来生成 gRPC 代码：

bash 复制代码 
mvn compile

或者

编译后，Protobuf 文件会被编译成 Java 类，生成的 gRPC 类会存放在 target/generated-sources/protobuf 目录中，并打包到 grpc-api 的 jar 文件中。

5. 创建用户服务模块

创建一个新的 Maven 模块（如 grpc-user），该模块将实现 gRPC 服务端，使用 grpc-api 共享的 gRPC 定义。

用户服务模块的 pom.xml

在 grpc-user 模块的 pom.xml 中，添加对 grpc-api 的依赖以及 gRPC 相关的依赖：

xml 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>yqmm-grpc</artifactId>
        <groupId>com.song</groupId>
        <version>1.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>grpc-user</artifactId>
    <description>服务端</description>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <grpc-service-version>2.14.0.RELEASE</grpc-service-version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.song</groupId>
            <artifactId>grpc-api</artifactId>
            <version>1.1-SNAPSHOT</version>
        </dependency>
<!--        服务端-->
        <dependency>
            <groupId>net.devh</groupId>
            <artifactId>grpc-server-spring-boot-starter</artifactId>
            <version>${grpc-service-version}</version>
        </dependency>
    </dependencies>
</project>
实现 gRPC 服务

在 grpc-user 模块中，基于 grpc-api 中的生成代码实现 gRPC 服务端：

java 复制代码 
/**
 * 自定义数据查询  提供给客户端数据
 */
@GrpcService
@Slf4j
public class UserService extends UserServiceGrpc.UserServiceImplBase{


    @Override
    public void getUserInfo(User.GetUserInfoRequest request,
                            StreamObserver<User.GetUserInfoResponse> responseObserver) {
        log.info("客户端发来的请求参数UserId>>>>>>>{}",request.getUserId());
        // todo 客户端发来的请求参数UserId 查询数据库db
        // todo 模拟db返回出来的用户数据
        User.GetUserInfoResponse response = User.GetUserInfoResponse.newBuilder()
                .setName("song-name")
                .setEmail("song.com")
                .setAddress("北京")
                .build();

        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

配置：application.yml

yml 复制代码 
grpc:
  server:
    port: 9190  # 设置 gRPC 服务器端口
server:
  port: 10002

spring:
  application:
    name: grpc-user

启动类

java 复制代码 
@SpringBootApplication
public class UserApplication {

    public static void main(String[] args) {
        SpringApplication.run(UserApplication.class, args);
    }
}

6. 创建订单服务模块

同样，创建订单服务模块（如 grpc-order），该模块将作为 gRPC 客户端调用用户服务。

订单服务模块的 pom.xml

在 grpc-order 模块的 pom.xml 中，添加对 grpc-api 模块的依赖以及 gRPC 相关的依赖：

xml 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>yqmm-grpc</artifactId>
        <groupId>com.song</groupId>
        <version>1.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>grpc-order</artifactId>
    <description>客户端</description>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <grpc-client-version>2.14.0.RELEASE</grpc-client-version>
    </properties>

    <dependencies>
<!--        客户端-->
        <dependency>
            <groupId>net.devh</groupId>
            <artifactId>grpc-client-spring-boot-starter</artifactId>
            <version>${grpc-client-version}</version>
        </dependency>
<!--        grpc-api -->
        <dependency>
            <groupId>com.song</groupId>
            <artifactId>grpc-api</artifactId>
            <version>1.1-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>
调用 gRPC 客户端

在 grpc-order 中，通过 gRPC 客户端调用用户服务获取用户信息：

java 复制代码 
@Service
public class UserClient {

    @GrpcClient("grpc-user") // yml里面指定访问服务端地址
    private UserServiceGrpc.UserServiceBlockingStub userServiceBlockingStub;



    public User.GetUserInfoResponse getUserInfo(String userId) {
        User.GetUserInfoRequest request = User.GetUserInfoRequest.newBuilder()
                .setUserId(userId)
                .build();
        return userServiceBlockingStub.getUserInfo(request);
    }
}
订单服务控制调用层

在订单服务中，可以使用 UserServiceClient 来获取用户信息并处理订单：

java 复制代码 
@RestController
public class OrderController {

    private final UserClient userClient;

    public OrderController(UserClient userClient) {
        this.userClient = userClient;
    }

    @GetMapping("/order")
    public String createOrder(@RequestParam String userId) {
        // 远程调用
        User.GetUserInfoResponse userInfo = userClient.getUserInfo(userId);
        // 处理订单逻辑
        return "为用户创建的订单：" + userInfo.getName()+userInfo.getAddress()+userInfo.getEmail();
    }
}

配置：application.yml

yml 复制代码 
server:
  port: 10001

grpc:
  client:
    grpc-user: # 自定义服务名
      address: 'static://127.0.0.1:9190' # 调用 gRPC 的地址
      negotiation-type: plaintext # 明文传输
spring:
  application:
    name: grpc-order

启动类

java 复制代码 
@SpringBootApplication
public class OrderApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
}

7. 启动和运行微服务

确保用户服务和订单服务的端口配置正确，启动两个服务：

  • 启动用户服务，它会在指定的 gRPC 端口监听（如 9190）。
  • 启动订单服务，通过 gRPC 客户端调用用户服务来获取用户信息并处理订单。
    调用地址
    http://localhost:10001/order?userId=123

    执行信息
相关推荐
黄油饼卷咖喱鸡就味增汤拌孜然羊肉炒饭1 小时前
SpringBoot如何实现缓存预热？
java·spring boot·spring·缓存·程序员
工业甲酰苯胺1 小时前
分布式系统架构：服务容错
数据库·架构
Java程序之猿3 小时前
微服务分布式(一、项目初始化)
分布式·微服务·架构
AskHarries3 小时前
Spring Cloud OpenFeign快速入门demo
spring boot·后端
isolusion4 小时前
Springboot的创建方式
java·spring boot·后端
Yvemil75 小时前
《开启微服务之旅：Spring Boot Web开发举例》（一）
前端·spring boot·微服务
小蜗牛慢慢爬行5 小时前
Hibernate、JPA、Spring DATA JPA、Hibernate 代理和架构
java·架构·hibernate
星河梦瑾6 小时前
SpringBoot相关漏洞学习资料
java·经验分享·spring boot·安全
思忖小下7 小时前
梳理你的思路(从OOP到架构设计)_简介设计模式
设计模式·架构·eit
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程