springboot 集成 grpc 和 protobuf（二） | 在实际项目中使用 grpc 和 protobuf

已于 2024-04-26 09:53:06 修改
阅读量5.4k 收藏 13
点赞数 6
分类专栏： grpc 文章标签： springboot grpc protobuf
于 2018-12-08 18:04:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25112523/article/details/84889951
版权

springboot 集成 grpc 和 protobuf（二） | 在实际项目中使用 grpc 和 protobuf

不熟悉grpc和protobuf的请参考第一篇：

springboot 集成 grpc 和 protobuf（一） | grpc和protobuf 的简介及本地使用.

注意：下面的测试代码写在同一个项目中！

一、项目结构：如下图

在这里插入图片描述

二、项目搭建

2.1 引入pom依赖：代码比较长，请耐心

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.45</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.9</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.0</version>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

        <!--使用grpc和protobuf-->
        <!-- protobuf依赖-->
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>3.5.1</version>
        </dependency>
        <!--grpc依赖-->
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-all</artifactId>
            <version>1.11.0</version>
        </dependency>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.25.Final</version>
        </dependency>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-tcnative-boringssl-static</artifactId>
            <version>2.0.8.Final</version>
        </dependency>

        <!--grpc客户端-->
        <dependency>
            <groupId>net.devh</groupId>
            <artifactId>grpc-client-spring-boot-starter</artifactId>
            <version>1.3.0-RELEASE</version>
        </dependency>
        <!--grpc服务端-->
        <dependency>
            <groupId>net.devh</groupId>
            <artifactId>grpc-server-spring-boot-starter</artifactId>
            <version>1.3.0-RELEASE</version>
        </dependency>
    </dependencies>

    <build>
        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.6.0</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>

            <!--跳过test测试-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <skip>true</skip>
                </configuration>
            </plugin>


            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.5.0</version>
                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:3.5.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>
                    <!--默认值-->
                    <protoSourceRoot>${project.basedir}/src/main/proto</protoSourceRoot>
                    <!--默认值-->
                    <!--<outputDirectory>${project.build.directory}/generated-sources/protobuf/java</outputDirectory>-->
                    <outputDirectory>${project.basedir}/src/main/java</outputDirectory>
                    <!--设置是否在生成java文件之前清空outputDirectory的文件，默认值为true，设置为false时也会覆盖同名文件-->
                    <clearOutputDirectory>false</clearOutputDirectory>
                </configuration>
                <executions>
                    <execution>
                        <!--在执行mvn compile的时候会执行以下操作-->
                        <phase>compile</phase>
                        <goals>
                            <!--生成OuterClass类-->
                            <goal>compile</goal>
                            <!--生成Grpc类-->
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

2.2 proto 文件介绍，第一篇也有介绍

文件名：data.proto
syntax = "proto3";

package example; //编译出来的文件存放目录

service FormatData {	
  rpc DoFormat(Data) returns (Data){}  //这里后面会用到，注意！！！
  // DoForma 客户端调用服务端使用的方法
  // Data 消息体，跟实体类类似，传参和返回都是一个实体接收
}

message Data {
  string text = 1;  // 1：代表第一个参数
  string flag = 2;  // 2：代表第二个参数
}

2.3 项目搭建好后，使用 maven 编译一下

在这里插入图片描述

2.4 然后会在java目录下生成：以Grpc结尾的文件才是连接的主要

2.4.1 DataOuterClass 文件是生成上面 data.proto 里面的message下面的 text 和 flag 参数的set和get方法，相当于实体Bean
2.4.2 FormatDataGrpc 文件是 grpc 的连接服务，下面会用这个调用

在这里插入图片描述

2.5 编写客户端：

在这里插入图片描述

三、代码编写：下面是先写的客户端代码，再写的服务端代码

客户端

3.1 application.yml文件配置（注意，yml文件中最下面url和端口根据启动项目打印的来，服务端有启动时有介绍）

server:
  port: 8078
  servlet:
    context-path: /huangtu-timer

# mysql
spring:
  # 环境 dev|test|prod
  profiles:
    active: test

logging:
  level: debug
  level.com.huangtu: debug
  path: logs/
  file: timer.log

# Grpc配置
grpc:
  client:
    local-grpc-server:
      #测试，大写转小写
      host: 0.0.0.0 		  #grpc服务端的 url
      port: 9090		      #grpc服务端的端口
      enableKeepAlive: true
      keepAliveWithoutCalls: true

3.2 客户端代码如下：一边参考 data.proto 文件一边理解更好

使用自动注入只需要配置yml中的即可，手动配置url和端口的话就注释上面的代码，放开下面代码的注释，然后直接用构造方法调用即可

import example.DataOuterClass;
import example.FormatDataGrpc;
import io.grpc.Channel;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import net.devh.springboot.autoconfigure.grpc.client.GrpcClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import types.Common;
import types.Unlock;
import types.WalletServiceGrpc;

import java.util.concurrent.TimeUnit;

/**
 * CreateBy: huangtu
 */
@Component
public class GrpcClientService {
    private Logger logger = LoggerFactory.getLogger(GrpcClientService.class);

    /** yml文件配置自动注入grpc的url和端口 */
//    @GrpcClient("local-grpc-server")
//    private Channel serverChannel;


    /**
     * 测试方法
     * @param letter        字母大小写转换
     */
//    public void sendMessage(String letter) {
        //将yml文件中的url和端口封装进连接服务 -- 
        //这里大部分都是一样的，proto文件里面的server是什么方法，这里就会自带 xxxxxBlockingStub
//        FormatDataGrpc.FormatDataBlockingStub stub = FormatDataGrpc.newBlockingStub(serverChannel);
        //调用连接方法，封装参数，进行传输和接收
        //自己自定义的 proto 文件直接参考替换类和方法就行
 //       DataOuterClass.Data data = stub.doFormat(DataOuterClass.Data.newBuilder().setText(letter).build());
 //       logger.info(data.getText()+"=======");
 //   }


    /** 手动配置grpc的url和端口 */
    private final ManagedChannel channel;
    private final FormatDataGrpc.FormatDataBlockingStub blockingStub;
    public GrpcClientService(String host, int port) {
        ManagedChannelBuilder<?> channelBuilder = ManagedChannelBuilder.forAddress(host, port).usePlaintext(true);
        channel = channelBuilder.build();
        blockingStub = FormatDataGrpc.newBlockingStub(channel);
    }

	/**
     * 停止连接---遇到异常可关闭连接----一般不用，因为连接是一直在的，报错看日志即可，关闭则需要重启服务端
     */
    public void shutdown() throws InterruptedException {
        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
    }
    
    /**
     * 测试方法
     * @param letter        字母：大小写转换
     */
    public void sendMessage(String letter) {
        //将yml文件中的url和端口封装进连接服务 -- 
        //这里大部分都是一样的，proto文件里面的server是什么方法，这里就会自带 xxxxxBlockingStub
        FormatDataGrpc.FormatDataBlockingStub stub = FormatDataGrpc.newBlockingStub(serverChannel);
        //调用连接方法，封装参数，进行传输和接收
        //自己自定义的 proto 文件直接参考替换类和方法就行
        DataOuterClass.Data data = stub.doFormat(DataOuterClass.Data.newBuilder().setText(letter).build());
        logger.info(data.getText()+"=======");
    }

}

服务端----

3.3 java服务端代码：

在这里插入图片描述

3.3.1 加入pom依赖：这里的服务端依赖已经在上面加了，所以可以不用重复加
<!--grpc服务端-->
<dependency>
    <groupId>net.devh</groupId>
    <artifactId>grpc-server-spring-boot-starter</artifactId>
    <version>1.3.0-RELEASE</version>
</dependency>
3.3.2 服务端代码
import example.DataOuterClass;
import example.FormatDataGrpc;
import io.grpc.stub.StreamObserver;
import net.devh.springboot.autoconfigure.grpc.server.GrpcService;

/**
 * CreateBy: huangtu
 */
@GrpcService(DataOuterClass.class)
public class GrpcServerService extends FormatDataGrpc.FormatDataImplBase {

    //注意，这里的 doFormat 方法，要跟dat.proto文件的server代码块里面的方法一样，注意大小写
    //因为我这里message 代码块 是Data。我自己既用它做传参也用它做返回
    //request是客户端传过来的参数，responseObserver是返回给客户端响应的参数
    public void doFormat(DataOuterClass.Data request, StreamObserver<DataOuterClass.Data> responseObserver) {
        String text = request.getText();
        StringBuffer stringBuffer = new StringBuffer();
        //大小写转换
        for(int i=0;i<text.length();i++) {
            //如果是小写
            if (text.substring(i, i + 1).equals(text.substring(i, i + 1).toLowerCase())) {
                stringBuffer.append(text.substring(i, i + 1).toUpperCase());
                System.out.print(text.substring(i, i + 1).toUpperCase());
            } else {
                stringBuffer.append(text.substring(i, i + 1).toLowerCase());
                System.out.print(text.substring(i, i + 1).toLowerCase());
            }
        }
        DataOuterClass.Data.Builder abc = DataOuterClass.Data.newBuilder().setText(stringBuffer.toString());
        //客户端每传一个消息过来都会调用一次onNext方法，当客户端发送完毕后，会执行onCompleted来返回一个对象给客户端
        responseObserver.onNext(abc.build());
        responseObserver.onCompleted();
    }
}

3.4 启动项目：

在用一个项目中即在控制台可以看到客户端需要访问服务端的URL和端口，如果是两个单独的项目，根据自己的配置来。

在这里插入图片描述

3.5 方法调用

注意：自己写个测试类，用main方法的话直接仿照我的即可。使用yml配置的方式的话就放开客户端 GrpcClientService 代码上面的注释，把下面的代码注释
main方法测试：
public static void main(String[] args) {
		//同一个项目启动，这里的端口和url跟日志上的一样。不同项目自己配置
        GrpcClientService client = new GrpcClientService ("0.0.0.0", 9090);
        try {
            client.sendMessage("aaBBcc======");
        } catch (Exception e) {
            client.shutdown();
        }
}
使用yml方式如下：
@Autowired
private GrpcClientService grpcClientService;

public void test(){
	grpcClientService.sendMessage("aaBBcc======");
}

3.6 返回结果

AAbbCC=============

四、扩展，遇到的bug

1. springboot集成grpc报错：io.grpc.StatusRuntimeException: UNAVAILABLE.
2. springboot集成grpc报错：io.grpc.StatusRuntimeException: INTERNAL: Connection closed with unknown cause.

欢迎关注公众号：慌途L
后面会慢慢将文章迁移至公众号，也是方便在没有电脑的情况下可以进行翻阅，更新的话会两边同时更新，大家不用担心！
在这里插入图片描述

慌途L
关注
  • 6
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
SpringBoot+gRPC+ProtoBuf实现远程服务调用
郄梦岩的博客
09-15 965
本文展示SpringBoot+gRPC完整版代码示例（客户端、服务端） 一、客户端 1.编写pom.xml导入对应的jar包 <dependency> <groupId>net.devh</groupId> <artifactId>grpc-spring-boot-starter</artifactId> <version>2.9.0.REL
android studio Kotlin中使用 GRPC和protobuf
07-04
在实际项目中，你可能需要考虑更多因素，如错误处理、连接管理、异步操作、多线程以及与现有系统的集成等。gRPC和protobuf的强大之处在于它们为这些挑战提供了成熟的解决方案，使得开发者可以专注于业务逻辑，而不是...
13. Springboot集成Protobuf
有一只柴犬的专栏
03-02 2935
在以往的项目中进行网络通信和数据交换的应用场景中，最经常使用的技术便是json或xml。随着JSON的灵活优势，越来越多的企业选择JSON作为数据交换的格式，目前JSON已经成为了业界的主流。JSON已经足够好用，且能满足相当大部分的场景。但是今天在介绍一个Google的力作protobuf作为数据交换格式。我们来看看。
Springboot集成GRPC
最新发布
qq_31564573的博客
05-22 898
Springboot2.1.3RELEASE 集成GRPC1.51.0
SpringBoot整合Netty并使用Protobuf进行数据传输(附工程)
weixin_33753003的博客
07-17 1149
前言 本篇文章主要介绍的是SpringBoot整合Netty以及使用Protobuf进行数据传输的相关内容。Protobuf会简单的介绍下用法，至于Netty在之前的文章中已经简单的介绍过了，这里就不再过多细说了。 Protobuf 介绍 protocolbuffer(以下简称PB)是google 的一种数据交换的格式，它独立于语言，独立于平台。google 提供了多种语言的实现：java、c#...
Springboot整合protobuf
热门推荐
tommer911
10-18 1万+
Springboot整合protobuf
springboot 集成 grpc 和 protobuf（一） | grpc和protobuf 的简介及本地使用
慌途L
12-08 3857
一，grpc简介： GRPC是google开源的一个高性能、跨语言的RPC框架，基于HTTP2协议，基于protobuf 3.x，基于Netty 4.x +。GRPC与thrift、avro-rpc等其实在总体原理上并没有太大的区别。 使用需知： 需要使用protobuf定义接口，即.proto文件 然后使用compile工具生成特定语言的执行代码，比如JAVA、C/C++、Python...
grpc 2 - protobuf 2
weixin_42306588的博客
08-11 142
主要尝试下protobuf里面提供的各种api，新建的测试文档如下： #include "user_info.pb.h" int main() { User test_1, test_2; // is initialized? std::cout << "is initialized?" << std::endl; std::cout << test_1.IsInitialized() << std::endl; std::cout
Springboot使用Netty集成protobuf客户端
dingdingdandang的博客
04-18 2550
Springboot-cli 开发脚手架系列 Netty系列：Springboot使用Netty集成protobuf开发客户端 文章目录Springboot-cli 开发脚手架系列前言1. 下载protoc.exe2. 编写.proto文件3. 生成.java 的协议包4. 引入协议文件5. 编写http测试接口6. 效果演示6. 源码分享 前言 首先我们需要使用Netty搭建基础的tcp客户端框架，参考Springboot使用Netty优雅的创建TCP客户端（附源码下载），接下来我们开始集成protu
springboot 整合grpc
09-04
2. **创建protobuf定义**：在项目中创建.proto文件，定义服务接口和消息类型。例如： ```protobuf syntax = "proto3"; service Greeter { rpc SayHello (HelloRequest) returns (HelloReply) {} } message ...
golang 微服务之gRPC与Protobuf的使用
09-17
在实际应用中，gRPC常被用在内部服务间通信或对性能、接口约束有严格要求的场景。 使用gRPC的基本流程包括： 1. **定义接口和数据类型**：使用Protobuf编写.proto文件，定义服务接口和服务消息。 2. **生成代码**：...
spring boot protobuf demo
07-05
spring boot protobuf demo
spring-boot-protobuf-serialization:这是一个展示如何在Web服务集成中使用Protobuf协议的项目
04-18
spring-boot-protobuf序列化 此仓库中的项目 spring-boot-serializations-producer：负责产生的Protobuf和json编码的数据。 默认情况下，该项目从端口8080开始，并公开2个终结点：一个公开JSON，一个公开Protobuf。 spring-boot-serializations-consumer：负责消耗生产者的端点（上面的项目）。 默认情况下，该项目从端口8081开始，并且取决于生产者才能正常工作。 该项目的主要目的是展示如何使用公开Protobuf编码数据的终结点。 检查类ProducerRestTemplate以查看实现。 使用的框架和库 Spring Boot版本2.1.8-用于公开Protobuf对象以及JSON的RESFull端点，也用于依赖注入和所有测试平台 Lombok-使用他的注释减少Java冗长 如何从本地
grpc-protobuf-1.24.0-API文档-中文版.zip
05-09
赠送jar包：grpc-protobuf-1.24.0.jar； 赠送原API文档：grpc-protobuf-1.24.0-javadoc.jar； 赠送源代码：grpc-protobuf-1.24.0-sources...人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
使用protobuf和gRPC实现消息订阅系统
01-12
在终端使用以下指令在python环境中安装grpc工具： sudo pip3 install grpcio-tools 1.2 proto文件的编写和处理 Protobuf是一套类似Json或者XML的数据传输格式和规范，用于不同应用或进程之间进行通信时使用。通信时...
grpc_grpc_protobuf_grpcdemo_
10-03
标题 "grpc_grpc_protobuf_grpcdemo_" 暗示我们正在探讨的是一个使用gRPC、Protocol Buffers（protobuf）以及一个名为 "grpcdemo" 的示例项目。在这个项目中，我们将深入理解如何利用gRPC和protobuf进行高效、跨平台...
protobuf（二）springboot整合protobuf传输数据
qly的博客
03-11 2206
springboot整合protobuf传输数据具体实践环境准备开发定义传输内容后端开发前端开发测试传输效果 具体实践 环境准备 后端 见博客：protobuf（一）认识protobuf 前端 1）nodejs： 官网下载；PS：本次我仍是利用浏览器作为js解释器 2）protbufjs：https://github.com/protobufjs/protobuf.js 开发 定义传输内容 首先，写一个.proto文件 后端开发 将.proto编译为.java 采用springboot框架，
springboot 中 protobuf + grpc的使用
weixin_40415768的博客
08-27 302
1：引入相关依赖 <?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://...
SpringBoot使用grpc优雅的编译protobuf
敲代码的旺财的博客
09-28 1442
目录一、介绍二、下载（非必要）三、idea安装protobuf插件（非必要）四、使用1、添加maven依赖2、添加maven插件3、创建定义文件4、使用maven创建对象5、直接在代码中使用 一、介绍   Protocol Buffer是Google的语言中立的，平台中立的，可扩展机制的，用于序列化结构化数据 - 对比XML，但更小，更快，更简单。您可以定义数据的结构化，然后可以使用特殊生成的源代码轻松地在各种数据流中使用各种语言编写和读取结构化数据。 官网地址：https://developers.goo
ubuntu20.04安装gRPC和protobuf库
05-26
要在Ubuntu 20.04上安装gRPC和protobuf库，请按照以下步骤进行操作： 1. 更新系统软件包列表 ``` sudo apt-get update ``` 2. 安装gRPC的依赖库 ``` sudo apt-get install build-essential autoconf libtool pkg-config ``` 3. 安装protobuf库 ``` sudo apt-get install protobuf-compiler libprotobuf-dev ``` 4. 安装gRPC ``` git clone -b v1.36.4 https://github.com/grpc/grpc cd grpc mkdir -p cmake/build cd cmake/build cmake ../.. make -j$(nproc) sudo make install ``` 这将会安装gRPC及其依赖项。 5. 验证安装 您可以使用以下命令验证gRPC和protobuf库的安装： ``` grpc_cpp_plugin --version protoc --version ``` 如果这些命令显示版本信息，则说明您已成功安装gRPC和protobuf库。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值