SpringBoot整合grpc

已于 2023-09-23 23:58:47 修改
阅读量5k 收藏 29
点赞数 17
文章标签： java 开发语言
于 2023-09-11 16:42:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38038507/article/details/132806964
版权

目录

一、简介

二、下图是通信流程模型 

三、准备

四、环境搭建

1、服务端server

1）pom文件

2）创建proto用于生成proto目标文件

 3）服务端yml配置

4）创建GrpcServerService实现服务端接口

2、客户端client

1）pom文件

2）创建proto用于生成proto目标文件

 3）客户端yml配置

4）创建GrpcClientService客户端类

5)创建SimpleGrpcController

五、启动/测试

1、服务端测试

2、客户端测试 

六、问题

七、源码验证解析

客户端

服务端 

一、简介

之所以会说grpc是高性能框架，默认情况下，gRPC基于Netty进行服务端和客户端互通，使用Protocol Buffers进行传输，这是Google用于序列化结构化数据的成熟开源机制，基于proto3情况下它还是一个跨语言的RPC框架（目前支持Java、c++、Dart、Python、Objective-C、c#、lite-runtime (Android Java)、Ruby和JavaScript(来自协议缓冲区GitHub repo)，以及来自golang/protobuf官方包的Go语言生成器） 

如果对grpc不够了解可以参考Introduction to gRPC | gRPC。

二、下图是通信流程模型 

  • 客户端(gRPC Stub)调用 A 方法，发起 RPC 调用。
  • 对请求信息使用 Protobuf 进行对象序列化压缩(IDL)。
  • 服务端(gRPC Server)接收到请求后，解码请求体，进行业务逻辑处理并返回。
  • 对响应结果使用 Protobuf 进行对象序列化压缩(IDL)。
  • 客户端接受到服务端响应，解码请求体。回调被调用的 A 方法，唤醒正在等待响应(阻塞)的客户端调用并返回响应结果。

三、准备

1、PROTOC下载及安装

下载地址

2、准备两个springboot项目，作为服务端和客户端

3、下载Apifox软件，用于直连服务端（可选）

下载地址

四、环境搭建

1、服务端server

1）pom文件
<!--部分配置-->
<dependencies>      
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-protobuf</artifactId>
            <version>${grpc.version}</version>
        </dependency>

        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-stub</artifactId>
            <version>${grpc.version}</version>
        </dependency>
        <!--gRPC服务端-->
        <dependency>
            <groupId>net.devh</groupId>
            <artifactId>grpc-server-spring-boot-starter</artifactId>
            <version>2.13.1.RELEASE</version>
        </dependency>


    </dependencies>
    <properties>
        <grpc.version>1.42.1</grpc.version>
        <protobuf.version>3.7.1</protobuf.version>
    </properties>
    <build>
        <finalName>${project.artifactId}-${project.version}</finalName>
        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.6.2</version>
            </extension>
        </extensions>

        <plugins>
            <!--            Grpc coding plug-in-->
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.6.1</version>
                <configuration>
                    <!--suppress UnresolvedMavenProperty -->
                    <!--&lt;!&ndash; ${os.detected.classifier} 变量由${os.detected.name} 和 ${os.detected.arch} 组成-->
                    <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
<!--                   protoSourceRoot 默认src/main/proto-->
<!--                    <protoSourceRoot>src/java/main/proto</protoSourceRoot>-->
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
2）创建proto用于生成proto目标文件

注意：proto文件需要创建在src/main/proto下，因为pom使用的是protoSourceRoot默认路径

创建Simple.proto 

syntax = "proto3"; // 协议版本

// 选项配置
option java_multiple_files = true;
//生成位置
option java_package = "com.na.model.proto";
option java_outer_classname = "SimpleProto";

service Simple {
  // 简单gRPC
  rpc OneToOne (MyRequest) returns (MyResponse) {
  }
}

message MyRequest {
  string name = 1;

  int32 value = 2;
}

message MyResponse {
  string message = 1;

  int64 result = 2;
}

 生成方式有两种一种是通过命令，这里使用maven插件生成compile和compile-custom

 编译后可在target下看到生成的相应的java类

 3）服务端yml配置

这里只贴出关键代码，其他配置根据实际情况来

# gRPC有关的配置，这里只需要配置服务端口号默认9090
grpc:
  server:
    port: 19898
spring:
  application:
    name: nacos-grpc

4）创建GrpcServerService实现服务端接口
package com.na.grpc.server;
import com.na.model.proto.MyRequest;
import com.na.model.proto.MyResponse;
import com.na.model.proto.SimpleGrpc;
import io.grpc.stub.StreamObserver;
import lombok.extern.slf4j.Slf4j;
import net.devh.boot.grpc.server.service.GrpcService;


/**
 * GrpcServerService.java中有几处需要注意：
 *
 * 是使用@GrpcService注解，再继承SimpleImplBase，这样就可以借助grpc-server-spring-boot-starter库将oneToOne暴露为gRPC服务；
 *
 * SimpleImplBase是前文中根据maven compile编译 proto文件自动生成的java代码，
 *
 * oneToOne方法中处理完毕业务逻辑后，调用responseObserver.onNext方法填入返回内容；
 *
 * 调用responseObserver.onCompleted方法表示本次gRPC服务完成；
 */
@GrpcService
@Slf4j
public class GrpcServerService extends SimpleGrpc.SimpleImplBase {

    @Override
    public void oneToOne(MyRequest request, StreamObserver<MyResponse> responseObserver) {
        log.info("接收客户端数据{}", request);
        MyResponse response = MyResponse.newBuilder().setMessage( request.getName()).build();
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }

}

2、客户端client

1）pom文件
<!--部分配置-->
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>  

        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-protobuf</artifactId>
            <version>${grpc.version}</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-stub</artifactId>
            <version>${grpc.version}</version>
        </dependency>
        <!--gRPC客户端-->
        <dependency>
            <groupId>net.devh</groupId>
            <artifactId>grpc-client-spring-boot-starter</artifactId>
            <version>2.14.0.RELEASE</version>
        </dependency>
    </dependencies>

    <properties>
        <grpc.version>1.42.1</grpc.version>
        <protobuf.version>3.7.1</protobuf.version>
    </properties>
    <build>
        <finalName>${project.artifactId}-${project.version}</finalName>

        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.6.2</version>
            </extension>
        </extensions>

        <plugins>
            <!--            Grpc coding plug-in-->
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.6.1</version>
                <configuration>
                    <!--suppress UnresolvedMavenProperty -->
                    <!--&lt;!&ndash; ${os.detected.classifier} 变量由${os.detected.name} 和 ${os.detected.arch} 组成-->
                    <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
<!--                   protoSourceRoot 默认src/main/proto-->
<!--                    <protoSourceRoot>src/java/main/proto</protoSourceRoot>-->
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
2）创建proto用于生成proto目标文件

与服务端操作一样，这里省略。。。。。。

 3）客户端yml配置

这里只贴出关键代码，其他配置根据实际情况来

server:
  port: 11278
  servlet:
    context-path: /
# grpc配置
grpc:
  # grpc clienT相关配置
  client:
    # 服务名（不同服务名可对应不同配置）
    # nacos-grpc是服务端配置的名字，GrpcClient注解会用到
    nacos-grpc:
#       gRPC服务端地址
#      address: 'dns://127.0.0.1:19898'
      address: 'static://127.0.0.1:19898'
      # 是否开启保持连接（长连接）
      enableKeepAlive: true
      # 保持连接时长（默认20s）
      keepAliveTimeout: 20s
      # 没有RPC调用时是否保持连接（默认false，可禁用避免额外消耗CPU）
      keepAliveWithoutCalls: false
      # 客户端负载均衡策略(round_robin（默认）, pick_first)
      defaultLoadBalancingPolicy: round_robin
      # 通信类型
      # plaintext | plaintext_upgrade | tls
      # 明文通信且http/2 | 明文通信且升级http/1.1为http/2 | 使用TLS（ALPN/NPN）通信
      negotiationType: plaintext
4）创建GrpcClientService客户端类
package com.na.grpc.client;

import com.na.model.proto.MyRequest;
import com.na.model.proto.MyResponse;
import com.na.model.proto.SimpleGrpc;
import io.grpc.StatusRuntimeException;
import lombok.extern.slf4j.Slf4j;
import net.devh.boot.grpc.client.inject.GrpcClient;
import org.springframework.stereotype.Service;

/**
 * GrpcClientService类有几处要注意的地方：
 * <p>
 * 用@Service将GrpcClientService注册为spring的普通bean实例；
 * <p>
 * 用@GrpcClient修饰SimpleBlockingStub，这样就可以通过grpc-client-spring-boot-starter库发起gRPC调用，被调用的服务端信息来自名为nacos-grpc服务端配置；
 * <p>
 * SimpleBlockingStub来自前文中根据helloworld.proto生成的java代码；
 * <p>
 * SimpleBlockingStub.oneToOne方法会远程调用nacos-grpc应用的gRPC服务；
 */
@Service
@Slf4j
public class GrpcClientService {

    @GrpcClient("nacos-grpc")
    private SimpleGrpc.SimpleBlockingStub simpleStub;

    public String oneToOne(final String name) {
        try {
            final MyResponse response = this.simpleStub.oneToOne(MyRequest.newBuilder().setName(name).build());
            return response.getMessage();
        } catch (final StatusRuntimeException e) {
            log.error("FAILED with " + e.getStatus().getCode().name() + ",and e:{}", e.getMessage());
            return "FAILED with " + e.getStatus().getCode().name() + ",and e:" + e.getMessage();
        }
    }
}
5)创建SimpleGrpcController

定义了两种连接方法getOneToOne和testForAddress

package com.na.controller;

import com.na.base.BaseResponse;
import com.na.grpc.client.GrpcClientService;
import com.na.model.proto.MyRequest;
import com.na.model.proto.SimpleGrpc;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description 测试grpc接口
 * @Author kele
 * @Data 2023/9/6 15:35
 */
@RestController
@RequestMapping("grpc")
public class SimpleGrpcController {
    @Autowired
    private GrpcClientService service;

    @GetMapping("getOneToOne")
    public BaseResponse getOneToOne() {
        return new BaseResponse(service.oneToOne("客户端kele连接"));
    }


    @GetMapping("testForAddress")
    public BaseResponse testForAddress() {
        ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 19898)
                .usePlaintext()
                .build();
        MyRequest request = MyRequest.newBuilder().setName("kele的访问").build();
        SimpleGrpc.SimpleBlockingStub stub = SimpleGrpc.newBlockingStub(channel);
        return new BaseResponse(stub.oneToOne(request));
    }

}

五、启动/测试

1、服务端测试

1）先启动服务端启动的netty端口为19898

2）使用Apifox连接服务端

创建grpc操作文档

可以看到，在Apifox中导入了Simple.proto帮我自动生成了客户端连接操作，自己只需要改一下19898端口和请求的参数

2、客户端测试 

1）启动客户端web端口为11278

2）直接通过web访问

这里访问的是getOneToOne方法， 地址http://localhost:11278/grpc/getOneToOne

另外的testForAddress方法可以自己玩一下生产一般不会那样写

六、问题报错

1、出现无法访问com.google.protobuf.GeneratedMessageV3 找不到com.google.protobuf.GeneratedMessageV，在pom中添加以下依赖。

        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>${protobuf.version}</version>
        </dependency>
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java-util</artifactId>
            <version>${protobuf.version}</version>
        </dependency>

2、出现：io.grpc.StatusRuntimeException: UNAVAILABLE

1、检查下IP是否能ping通，IP、端口 是否正确

2、Server是否打开

3、连接中如果有证书，证书是否有效

4、无证书的，是否写了明文连接，例如：

5、以上都没问题可以查看服务端是否添加了这个依赖，grpc-netty-shaded包中可能会存在core的冲突

        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-netty-shaded</artifactId>
            <version>${grpc.version}</version>
        </dependency>

七、源码验证解析

客户端

1、客户端序列化，可以查看MyRequest

 2、在客户端调用SimpleGrpc.SimpleBlockingStub.oneToOne方法时，已经将name序列化传输了

3、再往下可以看到客户端ClientCalls中，采用的是异步的方式进行发送二进制数据，等结束执行后再进行判断是否执行结束，

 waitAndDrain()即为等待，直到有一个Runnable，然后执行它和所有在它之后排队的Runnables。一次只能由一个线程调用。poll()方法用于从队列中取出并返回头部的元素，如果队列为空，则返回null。之后又将当前线程赋给了waiter，

 用的是线程池，在服务端断点的情况下，后续请求会进入等待队列。

服务端 

待更新。。。。。。

kele。
关注
SpringBoot集成gRPC，解决微服务之间的快速高效的内部通信问题
qq_18244417的博客
01-29 841
微服务架构和远程过程调用（RPC）实际上是互补的概念，而不是互斥的。在Java开发中，即便采用了微服务架构，也可能需要使用到RPC机制。为什么在微服务中仍然需要RPC？微服务架构是一种设计风格，它将应用程序构建为一组小的、独立运行的服务集合。每个服务都实现特定的业务功能，并且可以独立地部署和扩展。这些服务之间通常通过定义良好的API进行通信。远程过程调用（RPC）是一种协议，使得程序可以执行位于不...
Springboot集成GRPC
qq_31564573的博客
05-22 1824
Springboot2.1.3RELEASE 集成GRPC1.51.0
【gRPC-gateway】.yaml配置文件定义http规则以及网关上传文件，go案例
最新发布
m0_74282926的博客
02-13 1789
http。
springboot整合gprc 传输对象
carlos 程序员里最丑的
01-19 1万+
一，grpc简介： GRPC是google开源的一个高性能、跨语言的RPC框架，基于HTTP2协议，基于protobuf 3.x，基于Netty 4.x +。GRPC与thrift、avro-rpc等其实在总体原理上并没有太大的区别，简而言之GRPC并没有太多突破性的创新。    对于开发者而言：    1）需要使用protobuf定义接口，即.proto文件    2）然后使用compile工具...
Springboot 集成 GRPC
qq_18244417的博客
06-06 362
springboot 集成 GRPC(https://so.csdn.net/so/search?q=GRPC&spm=1001.2101.3001.7020)，需要做如下准备server 端client 端proto 文件相应的 pom步骤 1.创建 java maven 工程，使用 maven 对 Jar 包进行管理，工程目录如下：步骤 2.在 pom.xml...
springboot 集成GRPC
sunrj_niu的博客
10-19 2081
springboot 集成GRPC
springboot 整合grpc
09-04
SpringBoot 整合gRPC是一项将Google开发的高性能、开源的RPC框架gRPC与流行的Java微服务框架SpringBoot结合的技术实践。gRPC基于HTTP/2协议，使用Protocol Buffers（protobuf）作为数据交换格式，提供了强类型、高效...
springboot整合gRPC
08-11
- *1* [Springboot整合gRPC](https://blog.csdn.net/weixin_40395050/article/details/96971708)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...
SpringBoot整合Grpc实现跨语言RPC通讯
代码界的扛把子
04-30 1097
什么是gRPC gRPC是谷歌开源的基于go语言的一个现代的开源高性能RPC框架，可以在任何环境中运行。它可以有效地连接数据中心内和跨数据中心的服务，并提供可插拔的支持，以实现负载平衡，跟踪，健康检查和身份验证。它还适用于分布式计算的最后一英里，用于将设备，移动应用程序和浏览器连接到后端服务。 简单的服务定义:使用Protocol Buffers定义您的服务，这是一个功能强大的二进制序列化工具集和语言. 跨语言和平台工作:自动为各种语言和平台的服务生成惯用的客户端和服务器存根，当然单纯的java语言之
SpringBoot整合grpc server
taoyong920710的博客
08-26 198
address : 可指定某个地址才能访问. 例如: 127.0.0.1 限定只能本机访问.在模块的Plugins列表找到protobuf, 找到compile. 双击运行.3.将proto相关文件放到java的同级目录下.4.使用插件根据proto生产java代码.5.在配置文件中增加grpc的相关设置.运行后, 会自动生成java代码.继承的这个类是在第四步自动生成的.自己逻辑写在方法体内就可以了.2.然后是maven的插件.方法只覆写父类的方法.1.首先是项目依赖.port : 端口.
SpringBoot集成gRPC微服务工程搭建实践的方法
08-26
主要介绍了SpringBoot集成gRPC微服务工程搭建实践的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
使用spring boot集成grpc
jiayoubaobei2的博客
03-12 1185
grpc调用示例
Springboot整合gRPC
热门推荐
额滴神的博客
07-23 2万+
Springboot整合gRPC 概述： gRPC 一开始由 google 开发，是一款语言中立、平台中立、开源的远程过程调用(RPC)系统。 在 gRPC 里客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务。与许多 RPC 系统类似，gRPC 也是基于以下理念：定义一个服务，指定其能够被远程调用的方法（包含参数和返回类型）。在服务...
springboot整合grpc
夜一
07-29 572
一、创建项目 创建模块
gRPC - gRPC 整合 SpringBoot2.x、3.x（全代码、统一异常处理）
CYK_byte的博客
01-06 6390
b）这是因为我们在 client 模块中引入的依赖 "grpc-client-spring-boot-starter" 已经包含了 api 模块中引入的官方最新依赖，但是 client 中包含的依赖是 1.51.0 版本，而 api 模块中引入的是 1.60.0 版本。a）创建一个类，添加 @GrpcService 注解（注入容器中，表示它是一个 proto 文件中描述的 service 的实现类），让他继承对应的 Base 接口，重写 proto 文件中提供 service 下的方法即可.
Spring Boot如何快速集成gRpc
qq_33545255的博客
11-18 619
gRPC是一个现代的、高性能、开源和通用的RPC框架，由Google主导开发。它允许客户端和服务器应用程序之间进行透明的通信，并支持多种编程语言，包括Java、Go、Python等。gRPC基于HTTP/2协议设计，支持双向流、流控制、头部压缩等特性。创建一个.proto文件来定义gRPC服务接口和消息类型。
SpringBoot整合gRPC——入门级应用（详细注释）
weixin_53306150的博客
08-16 1695
一个简单的gRPCDemo，展示了阻塞调用和异步调用。如果有错误，欢迎大家指出，谢谢~
SpringBoot 集成gRPC高性能微服务框架
一碗清深的博客
08-28 634
在 gRPC 里，客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得我们能够更容易地创建分布式应用和服务。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值