0
0

SpringBoot使用GRPC框架(服务端)

概述:

GRPC是什么？ 首先我们知道 RPC是远程过程调用。

而GRPC是RPC的一种实现。 那么为什么要用GRPC呢？

因为它支持跨语言的开发，换句话说，大家都用过FeignRPC，尤其在spring cloud中。

然而它只支持java语言，而作为微服务，可能有很多其他的服务不是java开发的。

因此需要满足这个需求，就需要一个跨语言的RPC，所以就会考虑使用GRPC

使用流程(服务端):

流程:

先创建一个普通的Maven项目

导入依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.leadtrans</groupId>
    <artifactId>report</artifactId>
    <version>1.6.0</version>
    <name>report</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>11</java.version>
        <spring-cloud.version>2020.0.4</spring-cloud.version>
        <!--    GRPC    -->
        <grpc-spring-boot-starter.version>2.3.2</grpc-spring-boot-starter.version>
        <os-maven-plugin.version>1.6.0</os-maven-plugin.version>
        <protobuf-maven-plugin.version>0.5.1</protobuf-maven-plugin.version>
    </properties>
    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.78</version>
        </dependency>

        <!--    GRPC    -->
        <dependency>
            <groupId>org.lognet</groupId>
            <artifactId>grpc-spring-boot-starter</artifactId>
            <version>${grpc-spring-boot-starter.version}</version>
        </dependency>

    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <extensions>
            <!-- os-maven-plugin -->
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>${os-maven-plugin.version}</version>
            </extension>
        </extensions>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <skip>true</skip>
                </configuration>
            </plugin>
            <!-- protobuf-maven-plugin -->
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>${protobuf-maven-plugin.version}</version>
                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:3.5.1-1:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.11.0:exe:${os.detected.classifier}</pluginArtifact>
                    <outputDirectory>${project.build.sourceDirectory}</outputDirectory>
                    <clearOutputDirectory>false</clearOutputDirectory>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

创建proto文件夹:

proto文件夹必须和java文件夹同级

在文件夹下创建proto文件:

HelloWorld.protp

syntax = "proto3";

option java_multiple_files = true;
//生成grpc封装各种类的路径, 必须和SpringBoot启动类同级或更低
option java_package="com.example.test.helloworld";

//请求
message Request {
  double num1 = 1;
  double num2 = 2;
  OperateType opType = 3;
}

//操作类型
enum OperateType {
  Addition = 0;
  Division = 1;
  Multiplication = 2;
  Subtraction = 3;
}
//响应
message Response {
  double result = 1;
}

//定义服务
service Operate {
  rpc Calculate (Request) returns (Response);
}

按顺序执行指令

执行完之后会生成如下代码

** **

实现接口接收请求:

代码:

package com.hsy.test.helloworld;

import io.grpc.stub.StreamObserver;
import org.lognet.springboot.grpc.GRpcService;

@GRpcService
public class OperateImpl extends OperateGrpc.OperateImplBase {
    @Override
    public void calculate(Request request,
                          StreamObserver<Response> responseObserver) {
        Response response=Response.newBuilder().setResult(2).build();
        System.out.println(response);
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

** 注意事项:**

proto文件解释:

grpc返回集合数据:

在 gRPC 中，可以使用消息类型（Message）来表示集合。通常使用 Protocol Buffers 来定义 gRPC 中的消息类型。

假设定义了一个 User 消息类型:

proto文件:

syntax = "proto3";

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

** 如果要返回一个包含多个 User 对象的集合，可以定义一个消息类型，将多个 User 对象放在一个列表中。修改 UserList.proto 文件，添加一个新的消息类型 UserList：**


message UserList {
  repeated User users = 1;
}

** 在上面的定义中，使用了repeated 字段类型，表示该字段可以包含重复的值，也就是一个集合。**

完整proto文件:

syntax = "proto3";

option java_multiple_files = true;
//生成grpc封装各种类的路径, 必须和SpringBoot启动类同级或更低
option java_package="com.hsy.test.user";

//对象的属性
message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
}

//定义集合数据
message UserList {
  repeated User users = 1;
}

//请求
message UserRequest {
  string type = 1;
}

//响应
message UserResponse {
  UserList result = 1;
}

//定义服务
service Users {
  rpc list (UserRequest) returns (UserResponse);
}

响应接口实现:

@GRpcService
public class UserOperateImpl extends UsersGrpc.UsersImplBase {

    @Override
    public void list(UserRequest request, StreamObserver<UserResponse> responseObserver) {
        //根据名称获取参数
        String type = request.getType();
        //创建一个几个准备测试数据
        ArrayList<UserAA> users = new ArrayList<>();
        users.add(new UserAA(1, "zhangs", "[email protected]"));
        users.add(new UserAA(2, "lisi", "[email protected]"));
        users.add(new UserAA(3, "wangwu", "[email protected]"));
        //使用UserList的构建器创建一个新的 UserList.Builder对象
        UserList.Builder userList = UserList.newBuilder();
        //list.forEach(c ->{...}); 遍历 list 列表，对每个元素执行 lambda 表达式中的代码块。
        users.forEach(
                c -> {
                    //创建一个新的 StoreSystemBean.Builder 对象，并设置其属性值，然后将其添加到 resList 中。
                    User.Builder bean = User.newBuilder()
                            .setId(c.getId())
                            .setName(c.getName())
                            .setEmail(c.getEmail());
                    userList.addUsers(bean);
                }
        );
        //使用 StoreResponse 的构建器创建一个新的响应对象，并将其设置为包含 resList 的结果
        UserResponse response = UserResponse.newBuilder().setResult(userList).build();
        //将响应对象返回给客户端。
        responseObserver.onNext(response);
        //通知客户端，该调用已完成。
        responseObserver.onCompleted();

    }

}

实现类与proto文件的对应关系

设置grpc服务的端口号:

方式一:

在 gRPC 中，服务端和客户端通过网络进行通信，服务端必须公开端口来侦听客户端请求。在 gRPC 中为侦听客户端请求，通常可以通过以下方式来设置端口号：

  1. 在 gRPC Server 启动时，指定端口号。 在 Java 中，启动 gRPC Server 时可以使用 ServerBuilder 组件指定端口号和其他配置。例如：

在SpringBoot启动类中的main方法中添加如下代码

Server server = ServerBuilder.forPort(8088)
                      .addService(new MyServiceImpl())
                      .build();
server.start();

方式二:

使用 gRPC Server 上提供的绑定 API。 gRPC Server 提供了一个绑定 API，允许您在指定的 IP 和端口绑定服务。例如：

在SpringBoot启动类中的main方法中添加如下代码

Server server = ServerBuilder.forAddress(new InetSocketAddress("localhost", 8080))
                      .addService(new MyServiceImpl())
                      .build();
server.start();

在上述示例中，通过绑定地址 'localhost' 和端口 '8080'，可以将 gRPC 服务绑定到本地主机上的该端口上。

方式三:

在升级到gRPC v1.34及之后的版本中，还可以使用使用Bootstrap和SystemProperty配置端口的方式如下：

在SpringBoot启动类中的main方法 中添加如下代码

Bootstrap b = new Bootstrap();
b.group(new NioEventLoopGroup())
 .channel(EpollSocketChannel.class)
 .handler(new ChannelInitializer<SocketChannel>() {
     @Override
     protected void initChannel(SocketChannel ch) throws Exception {
         ChannelPipeline p = ch.pipeline();
         p.addLast(new GrpcClientInitializer());
     }
 });
System.setProperty("grpc.port", "8080");
ChannelFuture f = b.connect("localhost", Integer.parseInt(System.getProperty("grpc.port")));

在这种方式中，我们将grpc.port属性设置为端口号，而后使用Bootstrap配置客户端。

无论使用哪种方式来设置端口号，都需要确保端口号未被其他应用程序占用，并且需要部署到能够访问其所在网络的位置。

测试方式:

按图走

使用的是APIPOST工具

标签： spring boot java spring
本文转载自: https://blog.csdn.net/at_that_time/article/details/130959667
版权归原作者 你的配角i 所有， 如有侵权，请联系我们删除。
登录后发布评论

“SpringBoot使用GRPC框架(服务端)”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

腾讯EdgeOne产品测评体验——不仅仅是加速，更是您数字安全的坚实盾牌！

【Python爬虫实战】深入解锁 DrissionPage：ChromiumPage 自动化网页操作指南

【网络】H3C交换机配置

M1M2 MAC安装windows11 虚拟机的全过程

在 Git 中，获取提交的哈希值（commit hash）

Unity(2022.3.41LTS) - UI详细介绍- Panel(面板)和RectTransform组件

开源模型应用落地-Qwen2.5-7B-Instruct与TGI实现推理加速

文章导航