java 集成 protobuf及二次压缩

最新推荐文章于 2024-06-08 16:30:03 发布
最新推荐文章于 2024-06-08 16:30:03 发布
阅读量1.5k 收藏
点赞数
文章标签： java 开发语言 后端 protobuf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38060516/article/details/122100672
版权

一、创建springboot项目

1、创建proto文件目录 和 proto文件生成的java对象包

在这里插入图片描述

​

2、pom 中添加依赖包

## 版本
<grpc-version>1.6.1</grpc-version>
<protobuf-version>3.12.4</protobuf-version>        
## 依赖
<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>
<dependency>
	<groupId>com.googlecode.protobuf-java-format</groupId>
	<artifactId>protobuf-java-format</artifactId>
	<version>1.2</version>
</dependency>
<dependency>
	<groupId>io.grpc</groupId>
	<artifactId>grpc-netty</artifactId>
	<version>${grpc-version}</version>
</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>
<dependency>
	<groupId>io.protostuff</groupId>
	<artifactId>protostuff-core</artifactId>
	<version>1.7.4</version>
</dependency>
<dependency>
	<groupId>io.protostuff</groupId>
	<artifactId>protostuff-runtime</artifactId>
	<version>1.7.4</version>
</dependency>

3、编译proto文件，会自动生成class文件放到 proto包下

在这里插入图片描述

二、protobuf文件定义

1、proto3 对应各语言类型

.proto TypeNotesC++ TypeJava TypePython Type[2]Go Type
doubledoubledoublefloat*float64
floatfloatfloatfloat*float32
int32使用可变长度编码。编码负数的效率低 - 如果你的字段可能有负值，请改用 sint32int32intint*int32
int64使用可变长度编码。编码负数的效率低 - 如果你的字段可能有负值，请改用 sint64int64longint/long[3]*int64
uint32使用可变长度编码uint32int[1]int/long[3]*uint32
uint64使用可变长度编码uint64long[1]int/long[3]*uint64
sint32使用可变长度编码。有符号的 int 值。这些比常规 int32 对负数能更有效地编码int32intint*int32
sint64使用可变长度编码。有符号的 int 值。这些比常规 int64 对负数能更有效地编码int64longint/long[3]*int64
fixed32总是四个字节。如果值通常大于 228，则比 uint32 更有效。uint32int[1]int/long[3]*uint32
fixed64总是八个字节。如果值通常大于 256，则比 uint64 更有效。uint64long[1]int/long[3]*uint64
sfixed32总是四个字节int32intint*int32
sfixed64总是八个字节int64longint/long[3]*int64
boolboolbooleanbool*bool
string字符串必须始终包含 UTF-8 编码或 7 位 ASCII 文本stringStringstr/unicode[4]*string
bytes可以包含任意字节序列stringByteStringstr[]byte

2、定义proto文件

# 统一返回报文对象定义
syntax = "proto3";
option java_outer_classname = "ResultVo";
option java_package = "com.demo.proto";
import "google/protobuf/any.proto";

message ResultResponse {
  int32 code = 1;
  string msg = 2;
  google.protobuf.Any data = 3;# Any类型可代表proto对象
}

#返回业务Vo对象定义
syntax = "proto3";
option java_outer_classname = "AccountVo"; # java_outer_classname 的名字 要与 message 名字不同不然会编译不过
option java_package = "com.demo.proto";
message Account {
	//账号
	uint64 ID = 1;
	//名字
	string name = 2;
	//密码
	string password = 3;
	//临时
	string test = 4;
}


syntax = "proto3";
option java_outer_classname = "UserVo";
option java_package = "com.demo.proto";
import "Account.proto"; # 引入依赖对象
message User {
	Account user = 1;
}

三、自定义消息转换器HttpMessageConverter

转换器

package com.demo.configs.converter;

import com.demo.common.util.ZlibUtil;
import com.google.common.base.Stopwatch;
import com.google.protobuf.CodedOutputStream;
import com.google.protobuf.Descriptors;
import com.google.protobuf.Message;
import net.jpountz.lz4.LZ4BlockOutputStream;
import org.apache.commons.io.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConversionException;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.util.ConcurrentReferenceHashMap;
import org.xerial.snappy.SnappyOutputStream;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.nio.charset.Charset;
import java.util.Map;

public class ProtobufHttpMessageConverter extends AbstractHttpMessageConverter<Message> {
    private Logger logger = LoggerFactory.getLogger(getClass());
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
    public static final MediaType MEDIA_TYPE = new MediaType("application", "x-protobuf", DEFAULT_CHARSET);
    public static final MediaType MEDIA_TYPE_GZIP = new MediaType("application", "x-protobuf-zip", DEFAULT_CHARSET);
  
    private static final Map<Class<?>, Method> methodCache = new ConcurrentReferenceHashMap();
    /**
     * Construct a new instance.
     */
    public ProtobufHttpMessageConverter() {
        super(MEDIA_TYPE, MEDIA_TYPE_LZ4, MEDIA_TYPE_GZIP, MEDIA_TYPE_SNAPPY);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean canRead(final Class<?> clazz, final MediaType mediaType) {
        if(MEDIA_TYPE.isCompatibleWith(mediaType)
                ||MEDIA_TYPE_GZIP.isCompatibleWith(mediaType)){
            return true;
        }
        return false;
    }

    /**
     * {@inheritDoc}
     *  根据 mediaType判断需不需要走protobuf的转换
     */
    @Override
    public boolean canWrite(final Class<?> clazz, final MediaType mediaType) {
        if(MEDIA_TYPE.isCompatibleWith(mediaType)
                ||MEDIA_TYPE_GZIP.isCompatibleWith(mediaType)){
            return true;
        }
        return false;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected Message readInternal(final Class<? extends Message> clazz, final HttpInputMessage inputMessage)
            throws IOException, HttpMessageNotReadableException {
        Message.Builder builder = this.getMessageBuilder(clazz);
        // protobuf 序列化方式
        if (MEDIA_TYPE.isCompatibleWith(inputMessage.getHeaders().getContentType())) {
            builder.mergeFrom(inputMessage.getBody());
         //protobuf 序列化 + zlib 压缩   
        }else if(MEDIA_TYPE_GZIP.isCompatibleWith(inputMessage.getHeaders().getContentType())){
            ByteArrayOutputStream outputStream = null;
            try {
                long time = System.currentTimeMillis();
                InputStream inputStream = inputMessage.getBody();
                HttpHeaders httpHeaders = inputMessage.getHeaders();
                Descriptors.Descriptor descriptor =  builder.getDescriptorForType();
                Descriptors.FieldDescriptor fieldDescriptorLength = descriptor.findFieldByNumber(25);
                Descriptors.FieldDescriptor fieldDescriptorTime = descriptor.findFieldByNumber(26);
                Long length = httpHeaders.getContentLength();
                byte[] bytes = new byte[1024];
                outputStream = new ByteArrayOutputStream(length.intValue());
                int i =0;
                while ( (i = inputStream.read(bytes)) > 0){
                    outputStream.write(bytes,0,i);
                }
                byte[] data = ZlibUtil.uncompress(outputStream.toByteArray(),false);
                logger.info("压缩前的数据长度={}",data.length);
                //httpHeaders.add("uncompressLength",data.length+"");
                builder.setField(fieldDescriptorLength,data.length+"");
                builder.mergeFrom(data);
                long time2 = System.currentTimeMillis();
                logger.info("解压数据耗时---{}--长度={}",time2-time,length);
                //httpHeaders.add("uncompressTime",(time2-time)+"");
                builder.setField(fieldDescriptorTime,((time2-time)==0?1:(time2-time))+"");

            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                if(outputStream != null){
                    outputStream.close();
                }
            }

        }
        return builder.build();
    }

    private Message.Builder getMessageBuilder(Class<? extends Message> clazz) {
        try {
            Method method = (Method)methodCache.get(clazz);
            if (method == null) {
                method = clazz.getMethod("newBuilder");
                methodCache.put(clazz, method);
            }

            return (Message.Builder)method.invoke(clazz);
        } catch (Exception var3) {
            throw new HttpMessageConversionException("Invalid Protobuf Message type: no invocable newBuilder() method on " + clazz, var3);
        }
    }
    /**
     * {@inheritDoc}
     */
    @Override
    protected boolean supports(final Class<?> clazz) {
        // Should not be called, since we override canRead/canWrite.
        throw new UnsupportedOperationException();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected void writeInternal(Message message, HttpOutputMessage outputMessage)
            throws IOException, HttpMessageNotWritableException {
        if (logger.isDebugEnabled()) {
            logger.info("Current type: {}", outputMessage.getHeaders().getContentType());
        }
        Stopwatch stopwatch = Stopwatch.createStarted();
        OutputStream stream = null;

        try {
            stream = outputMessage.getBody();
            if (MEDIA_TYPE.isCompatibleWith(outputMessage.getHeaders().getContentType())) {
                this.setProtoHeader(outputMessage, message);
                CodedOutputStream codedOutputStream = CodedOutputStream.newInstance(outputMessage.getBody());
                message.writeTo(codedOutputStream);
                codedOutputStream.flush();
                return;
            } else if (MEDIA_TYPE_GZIP.isCompatibleWith(outputMessage.getHeaders().getContentType())) {
                byte[] bytes = message.toByteArray();
                stream.write(ZlibUtil.compress(bytes,false));
                stream.flush();
            } else if (MEDIA_TYPE_LZ4.isCompatibleWith(outputMessage.getHeaders().getContentType())) {
                stream = new LZ4BlockOutputStream(stream);
            } else if (MEDIA_TYPE_SNAPPY.isCompatibleWith(outputMessage.getHeaders().getContentType())) {
                stream = new SnappyOutputStream(stream);
            } else {
               return;
            }

           message.writeTo(stream);
        } finally {
            IOUtils.closeQuietly(stream);
        }
        if (logger.isDebugEnabled()) {
            logger.info("Output spend {}", stopwatch.toString());
        }
    }
    private void setProtoHeader(HttpOutputMessage response, Message message) {
        response.getHeaders().set("X-Protobuf-Schema", message.getDescriptorForType().getFile().getName());
        response.getHeaders().set("X-Protobuf-Message", message.getDescriptorForType().getFullName());
    }
}

zlib解压缩工具

public class ZlibUtil {
    public static byte[] uncompress(byte[] input, boolean nowrap) throws IOException {
        Inflater inflater = new Inflater(nowrap);
        inflater.setInput(input);
        ByteArrayOutputStream baos = new ByteArrayOutputStream(input.length);
        try {
            byte[] buff = new byte[1024];
            while (!inflater.finished()) {
                int count = inflater.inflate(buff);
                /*if(count == 0){
                    break;
                }*/
                baos.write(buff, 0, count);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            baos.close();
        }
        inflater.end();
        byte[] output = baos.toByteArray();
        return output;
    }

    public static byte[] compress(byte[] data, boolean nowrap) throws IOException {
        byte[] output;
        Deflater compress = new Deflater(Deflater.BEST_COMPRESSION, nowrap);
        compress.reset();
        compress.setInput(data);
        compress.finish();
        ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length);
        try {
            byte[] buf = new byte[1024];
            while (!compress.finished()) {
                int i = compress.deflate(buf);
                bos.write(buf, 0, i);
            }
            output = bos.toByteArray();
        } catch (Exception e) {
            output = data;
            e.printStackTrace();
        } finally {
            bos.close();
        }
        compress.end();
        return output;
    }
}

四、Controller 层定义

 
   /**
     * 查询数据接口 ,请求接口时 ，content-type = 'application/x-protobuf-zip'
     * produces = "application/x-protobuf-zip" 自定义消息转换器会根据 这个mediaType类型判断，是否将返回信息封装成protobuf系列化    +zlib压缩
     * @param request
     * @param calResultQuery
     * @return
     */
    @PostMapping(value = "queryResult", produces = "application/x-protobuf-zip" )
    @ResponseBody
    public ResultVo.ResultResponse queryResult(HttpServletRequest request,@RequestBody CalResultQueryVO calResultQuery){
        ResultVo.ResultResponse.Builder resultResponse = ResultVo.ResultResponse.newBuilder();
        try {
            String globalId = (String) request.getAttribute("globalId");
            CalResultVO.CalResult calResult = parseProtoDataManager.parseResultData(calResultQuery,globalId);
            resultResponse.setData(Any.pack(calResult));
            resultResponse.setCode(Integer.valueOf(ErrorCode.SYS_CODE_200));
            resultResponse.setMsg("下载数据成功");
        }catch (Exception e){
            e.printStackTrace();
            resultResponse.setCode(Integer.valueOf(ErrorCode.SYS_CODE_500));
            resultResponse.setMsg("下载数据失败"+e.getMessage());
        }
        return resultResponse.build();
    }
西红柿炒番茄♂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
protobuf gzip压缩 解压缩的使用方法
yangzm的专栏
06-09 1382
#include <google/protobuf/io/gzip_stream.h> #include <google/protobuf/io/zero_copy_stream_impl.h> std::string output; // 压缩序列化 google::protobuf::io::GzipOutputStream::Options options; options.format = google::protobuf::io::GzipOutputStream::GZ.
ProtoBuf 实际应用（java）
专注基础架构领域
04-19 1447
在实际的应用之前，我们再了解以下protobuf。 通过比较它与其他数据格式进行比较，可以使我们更好的认识它的应用场景。下面与XML，JSON进行一个简单的比较。 JSON：一般在web项目中广泛使用，主要是由于浏览器的支持非常好，内部构建了与多函数来支持JSON。具有可读性。 XML：在WebService中广泛使用，但是过于冗余(毕竟是通过标签进行标识)。也具有可读性。 ProtoBuf：适合高性能，对响应速度有要求的数据传输场景。由于是二进制数据格式需要编码和解码。不具有可读
Rust : windows下protobuf和压缩传输方案
最新发布
Julia & Rust & Python
06-08 831
proto文件中主要模拟了一个dbpystream中一个get_price函数的输入和输出的格式，输入HistoryBarRequest ，输出HistoryBarResponse。HistoryBarResponse中，有代码名称，日期，开盘价，最高价等。上面polars，chrono,prost-types,prost-build，prost是关键库，其它暂时可以不看。可见，在src/目录下，创建了一个pb文件夹，存放未来生成的dbdata.proto文件。四、原始数据、main.rs。
protobuf-java-util-3.1.0.jar
10-11
protobuf-java-util-3.1.0.jar下载，配合protobuf3.1.jar的util包
Protobuf在java中的简单使用实例
热门推荐
weixin_44642924的博客
09-23 1万+
protobuf是一种跨语言的数据转换协议，由google开源的，已支持大部份语言。在一般的数据交互过程中都是使用json,xml等来做数据的转换，这其中涉及复杂的解析与序列化反序列化问题，如果在大量数据并发请求时，也会导致性能问题。protobuf采用Varint编码技术，在某种程度上减少数字的字节数，关于Varint的实现原理可以参考： https://segmentfault.com/a/1190000020500985?utm_source=tag-newest 由于protobuf是跨语言的，
Java整合Protobuf的使用
ctycsdn的博客
11-03 1035
一、先编写对应的protobuf文件 syntax = "proto3"; import "google/protobuf/wrappers.proto"; option java_package = "com.qw.ad.controller.rta.proto"; option java_outer_classname = "RtaApi"; enum PlatformType { PLATFORM_UNKNOWN = 0; ANDROID = 1; IOS = 2; } en
高效的数据压缩编码方式 Protobuf
weixin_33786077的博客
05-31 775
一. protocol buffers 是什么？ Protocol buffers 是一种语言中立，平台无关，可扩展的序列化数据的格式，可用于通信协议，数据存储等。 Protocol buffers 在序列化数据方面，它是灵活的，高效的。相比于 XML 来说，Protocol buffers 更加小巧，更加快速，更加简单。一旦定义了要处理的数据的数据结构之后，就可以利用 Protocol buff...
Netty中集成Protobuf实现Java对象数据传递示例代码.rar
09-19
在Netty中集成Protobuf，主要目的是利用Protobuf的数据序列化能力，将Java对象转换为字节流，然后通过Netty的Channel发送到网络，接收端再反序列化恢复成原来的对象。具体步骤如下： 1. 定义消息：首先创建一个....
基于Protobuf动态解析在Java中的应用 包含例子程序
08-29
基于Protobuf动态解析在Java中的应用 Protocol Buffers（protobuf）是一种结构化数据格式标准，由Google开发，提供了序列化和反序列方法，用于存储和交换。protobuf语言中立，平台无关、可扩展。protobuf官方提供了...
Java 和 protobuf 3.5开发实例一
12-17
在本文中，我们将深入探讨如何使用Java与Protocol Buffers（protobuf）3.5版本进行开发。Protocol Buffers是Google推出的一种高效的数据序列化协议，它允许开发者定义数据结构，然后生成能够在各种数据平台之间轻松...
java生成protobufdemo直接运行
01-12
运行这个Java程序，将会在项目目录下生成一个名为`person.pb`的protobuf二进制文件，并打印出解析后的Person对象信息。 总结 本教程介绍了如何使用Java和protobuf编译器生成protobuf Java类，并展示了如何在Java...
protobuf序列化JAVA使用的JAR包V3.15
06-09
这些生成的类包含了序列化和反序列化的API，使得开发者可以轻松地在Java对象和protobuf二进制格式之间转换。 在编码阶段，可以通过protobuf的API创建、填充和读取protobuf消息。例如： ```java Person person = ...
grpc 4种模式介绍及java代码示例
西凉的悲伤博客
07-12 2979
🐹gRPC：grpc 是 Google 开发的一种开源 RPC（Remote Procedure Call Protocol 远程过程调用的协议）框架，在 gRPC 中，客户端应用程序可以像本地对象一样直接调用不同机器上的服务器应用程序上的方法，从而使您可以更轻松地创建分布式应用程序和服务。如果你的 java 项目里有 A 和 B 两个类，A 中有 aa 方法，B 中有 bb 方法，你可以很容易的在 aa 里调用 bb 方法。
java中使用protobuf的详细说明
weixin_42684368的博客
08-02 1914
介绍protobuf在java中的使用
protobuf3-java使用
我玩的很开心的博客
01-02 1775
Protobuf
java多重打包解压ZIP文件
yqf19890729的专栏
02-17 500
今天用到了ZIP，涉及多重打包解压zip 在网上搜了下。组要导入额外的jar包。不符合自己的要求，就自己写了个 实现把文件重复压缩两次（压缩文件里面还是压缩文件），主要是采用一个缓冲保存第一次压缩结果。然后再来压缩一次就可以了 压缩 [code="java"] package net.xf; import java.io.BufferedOutputStream; ...
java protobuf 反射_Protobuf与POJO的相互转化 - 通过Json
weixin_42519514的博客
02-12 861
前言这篇文章是《Protobuf与Json的相互转化》的一个后续，主要是为了解决系统分层中不同ProtoBean与POJO的相互转化问题。转化的Protobuf和Pojo具有相同名称及类型的属性(当Proto属性类型为Message时，对应的为Pojo的Object类型的属性，两者应该具有相同的属性)。转化的基本思路测试使用的protobuf文件如下：StudentProto.protosynta...
悟空云课堂 | 第三十二期：不受控制的资源消耗（CWE-400:Uncontrolled Resource Consumption）
Tianqi_Wukong的博客
01-20 836
悟空云课堂 | 第三十二期：不受控制的资源消耗（CWE-400:Uncontrolled Resource Consumption） 01 什么是不受控制的资源消耗缺陷？ 软件无法正确控制有限资源的分配和维护，从而使参与者无法影响所消耗的资源量，最终导致可用资源的耗尽。有限的资源包括内存，文件系统存储，数据库连接池条目和CPU。 如果攻击者可以触发这些有限资源的分配，但是资源的数量或大小不受控制，则攻击者可能会导致拒绝服务，从而消耗所有可用资源。这将阻止有效用户访问该软件，并且可能对周围环境产生影响。 例如
protobuf的GZIP压缩
ldahual的博客
04-02 3538
protobuf的GZIP压缩 protobuf自带压缩功能，可选的压缩算法有 GZIP 和 ZLIB 序列化至iostream 序列化示例： std::ofstream output("scene.art", std::ofstream::out | std::ofstream::trunc | std::ofstream::binary); OstreamOutputStream outputFileStream(&output); GzipOutputStream::Options optio
java android集成protobuf
05-13
在 Android 中集成 protobuf 需要进行以下步骤： 1.在项目级别的 build.gradle 文件中添加如下依赖： ``` dependencies { implementation 'com.google.protobuf:protobuf-java:3.12.4' implementation 'com.google.protobuf:protobuf-lite:3.0.0' } ``` 2. 在 app 模块级别的 build.gradle 文件中添加如下配置： ``` protobuf { protoc { artifact = 'com.google.protobuf:protoc:3.12.4' } plugins { javalite { artifact = 'com.google.protobuf:protoc-gen-javalite:3.0.0' } } generateProtoTasks { all().each { task -> task.plugins { javalite {} } } } } ``` 3.在 app 模块的 src/main 目录下创建 proto 目录，并在此目录下放置 proto 文件。 4.执行以下命令，生成 Java 代码： ``` ./gradlew clean build ``` 5.在代码中使用生成的 Java 类。例如： ``` PersonProto.Person person = PersonProto.Person.newBuilder() .setId(1) .setName("John Doe") .setEmail("johndoe@example.com") .build(); ``` 以上就是在 Android 中集成 protobuf 的步骤。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值