关于protobuf:Protobuf专题二Protobuf的数据类型解析及使用总结

0 前言

Protobuf（Protocol Buffer）是Google出品的一种轻量且高效的结构化数据存储格局，性能比Json、XML更强，被广泛应用于数据传输中。然Protobuf中的数据类型泛滥，什么场景利用什么数据类型最正当、最省空间，成为了每个使用者该思考的问题。为了能更充沛的了解和应用Protobuf，本文将聚焦Protobuf的根本数据类型，剖析其不同数据类型的应用场景和注意事项。

留神：在浏览本文之前最好对Protobuf的语法和序列化原理有肯定的理解。
举荐文献：
【1】序列化：这是一份很有诚意的 Protocol Buffer 语法详解 https://blog.csdn.net/carson_...
【2】Protocol Buffer 序列化原理大揭秘 - 为什么Protocol Buffer性能这么好？https://blog.csdn.net/carson_...
【3】通过一个残缺例子彻底学会protobuf序列化原理https://cloud.tencent.com/dev...

1 根本数据类型的范畴

整型范畴

Int8 - [-128 : 127]
Int16 - [-32768 : 32767]
Int32 - [-2147483648 : 2147483647]
Int64 - [-9223372036854775808 : 9223372036854775807]

无符号整型范畴

UInt8 - [0 : 255]
UInt16 - [0 : 65535]
UInt32 - [0 : 4294967295]
UInt64 - [0 : 18446744073709551615]

浮点数范畴

Float（32bit） = 1bit（符号位）+ 8bits（指数位）+ 23bits（尾数位）
指数位的范畴为-2^128 ~ +2^128
尾数位的范畴为2^23 = 8388608，一共七位，这意味着最多能有7位有效数字，但相对能保障的为6位，也即float的精度为6~7位有效数字；
Double（64bit）= 1bit（符号位）+ 11bits（指数位）+ 52bits（尾数位）
指数位的范畴为-2^1024 ~ +2^1024
尾数位的范畴为2^52 = 4503599627370496，一共16位，同理，double的精度为15~16位。

浮点数的存储形式详见：https://cloud.tencent.com/dev...

2 Protobuf的数据类型

Protobuf的根本数据类型与JAVA的数据类型映射关系表如下：

映射表来源于Protobuf官网，https://developers.google.com...

留神到JAVA中没有辨别无符整型和有符整型，Protobuf的int和uint对立映射到JAVA的int/long数据类型。

Protobuf数据类型的序列化办法粗略能够分为两种，一种是可变长编码（如Varint），Protobuf会正当调配空间存储数据，在保障不损失精度的状况下用尽量小的空间节俭内存（比方整数1，若数据定义的类型为int32，原本须要8个字节表白的，Protobuf只须要一个字节表白。留神，Protobuf只能节俭到字节的单位（8个字节俭到1个字节），而不能节俭到位的单位（1个字节内还能够进一步省二进制位），这个后续开专题再聊）；另一种是固定长度编码（如64-bit、32-bit），数据定义的什么类型就占用多大空间，不论是否有节约；其实，还有一种比拟特地的办法（Length-delimited），这种办法次要针对相似于数组的数据，增加了一个字段记录数组的长度，而后将数组内容程序组合，具体原理不在赘述，可见前文举荐的文献。

3 数据试验

为验证Protobuf各数据类型的序列化成果，遂设计以下数据试验。

1、首先，自定义了proto文件，使其中蕴含根本数据类型，并将proto生成java类（如何基于IDEA一站式编辑及编译proto文件，详见上一篇专题文章https://segmentfault.com/a/11...）。
proto文件内容如下：

// Google Protocol Buffers Version 3.syntax = "proto3";option java_package = "learnProto.selfTest";option java_outer_classname = "MyTest";message Data{    uint32 uint32 = 1;    uint64 uint64 = 2;    int32  int32 = 3;    int64  int64 = 4;    sint32 sint32 = 5;    sint64 sint64 = 6;    fixed32 fixed32 = 7;    fixed64 fixed64 = 8;    bool bool=9;    string str = 10;    float  float=11;    double double=12;}

2、其次，别离对每个数据类进行赋不同的值并序列化，察看不同数据序列化后占用的字节数。
3、最初，总结演绎，造成应用倡议。

3.1 整数型数据试验

测试代码如下:

public class demoTest {    public void convertUint32(int value) {        //1.通过build创立音讯结构器        MyTest.Data.Builder dataBuilder = MyTest.Data.newBuilder();        //2.设置字段值        dataBuilder.setUint32(value);        //3.通过音讯结构器结构音讯对象        MyTest.Data data = dataBuilder.build();        //4.序列化        byte[] bytes = data.toByteArray();        System.out.println(value+"序列化后的数据：" + Arrays.toString(bytes)+",字节个数："+bytes.length);    }    ...  // 此处省略其余数据类型的convert办法，如convertInt32与convertUint32办法代码相似，只须要批改set办法即可。        @Test    public void test32(){        System.out.println("=================uint32================");        convertUint32(1);        convertUint32(1000);        convertUint32(Integer.MAX_VALUE);        convertUint32(-1);        convertUint32(-1000);        convertUint32(Integer.MIN_VALUE);        System.out.println("=================int32================");        convertInt32(1);        convertInt32(1000);        convertInt32(2147483647);        convertInt32(-1);        convertInt32(-1000);        convertInt32(-2147483648);        System.out.println("=================sint32================");        convertSint32(1);        convertSint32(1000);        convertSint32(2147483647);        convertSint32(-1);        convertSint32(-1000);        convertSint32(-2147483648);        System.out.println("=================fix32================");        convertFixed32(1);        convertFixed32(1000);        convertFixed32(2147483647);        convertFixed32(-1);        convertFixed32(-1000);        convertFixed32(-2147483648);    }

运行后果如下：

=================uint32================1序列化后的数据：[8, 1],字节个数：21000序列化后的数据：[8, -24, 7],字节个数：32147483647序列化后的数据：[8, -1, -1, -1, -1, 7],字节个数：6-1序列化后的数据：[8, -1, -1, -1, -1, 15],字节个数：6-1000序列化后的数据：[8, -104, -8, -1, -1, 15],字节个数：6-2147483648序列化后的数据：[8, -128, -128, -128, -128, 8],字节个数：6=================int32================1序列化后的数据：[24, 1],字节个数：21000序列化后的数据：[24, -24, 7],字节个数：32147483647序列化后的数据：[24, -1, -1, -1, -1, 7],字节个数：6-1序列化后的数据：[24, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1],字节个数：11-1000序列化后的数据：[24, -104, -8, -1, -1, -1, -1, -1, -1, -1, 1],字节个数：11-2147483648序列化后的数据：[24, -128, -128, -128, -128, -8, -1, -1, -1, -1, 1],字节个数：11=================sint32================1序列化后的数据：[40, 2],字节个数：21000序列化后的数据：[40, -48, 15],字节个数：32147483647序列化后的数据：[40, -2, -1, -1, -1, 15],字节个数：6-1序列化后的数据：[40, 1],字节个数：2-1000序列化后的数据：[40, -49, 15],字节个数：3-2147483648序列化后的数据：[40, -1, -1, -1, -1, 15],字节个数：6=================fix32================1序列化后的数据：[61, 1, 0, 0, 0],字节个数：51000序列化后的数据：[61, -24, 3, 0, 0],字节个数：52147483647序列化后的数据：[61, -1, -1, -1, 127],字节个数：5-1序列化后的数据：[61, -1, -1, -1, -1],字节个数：5-1000序列化后的数据：[61, 24, -4, -1, -1],字节个数：5-2147483648序列化后的数据：[61, 0, 0, 0, -128],字节个数：5

【小结】
1、 uint32类型：数值范畴等价于int32的范畴（能够存正数，因为proto没有对正数进行判断及限度）。正数最多占用5个字节，正数必占用5个字节。（第一个字节存储的是数据类型和字段在proto中的编号，即原理篇里讲的tag。之所以32位的数据最多要用5个字节来存储，是因为每个字节的最高位须要记录该数据是否衍生到下个字节（为实现可变长存储），1示意衍生，0示意不衍生。所以每个字节的理论存储数据的位数为7，则4*7<32，因而须要5个字节）

2、 int32类型：存负数时最多须要5个字节，存正数时必然须要10个字节。（因为存正数时，32位被扩大成了64位，具体起因临时不明，晓得的敌人请赐教）

3、 sint32类型：存数据时引入zigzag编码（Zigzag(n) = (n << 1) ^ (n >> 31), n 为 sint32 时，去掉了符号转为负数），目标是解决正数太占空间的问题。正负数最多占用5个字节，内存高效。

4、 fixed32类型：固定应用4个字节，即正负数必然占用4个字节。因为摈弃了可变长存储的策略。适宜用于存储数据大值占比多的字段。

64位的法则与32相似，不再赘述。

3.2 字符串类型数据试验

测试代码如下：

@Testpublic void testStr() {    System.out.println("=================string================");    convertStr("");    convertStr("a");    convertStr("abc");    convertStr("啊");    convertStr("啊啊");}

运行后果如下：

=================string================序列化后的数据：[],字节个数：0a序列化后的数据：[82, 1, 97],字节个数：3abc序列化后的数据：[82, 3, 97, 98, 99],字节个数：5啊序列化后的数据：[82, 3, -27, -107, -118],字节个数：5啊啊序列化后的数据：[82, 6, -27, -107, -118, -27, -107, -118],字节个数：8

【小结】
string类型：proto3中字符串默认为值为空字符串，序列化后不占用内存空间；单个英文字符占1个字节，单个中文字符占3个字节（proto采纳utf-8编码）。

3.3 布尔值类型数据试验

测试代码如下：

@Testpublic void testbool() {    System.out.println("=================bool================");    convertBool(false);    convertBool(true);}

运行后果如下：

=================bool================false序列化后的数据：[],字节个数：0true序列化后的数据：[72, 1],字节个数：2

【小结】
bool类型：proto3中布尔值默认为值为fasle，因而当值为false时，序列化后不占用内存空间；当布尔值为true时，占用1个字节。

3.4 浮点型数据试验

浮点型数据都采纳的定长编码，其自身没有测试的必要，但在理论利用中，很多浮点型数据（比方经纬度坐标）其实能够转化为肯定精度的整数的（容许肯定的精度损失），在该场景下，是应用整数型好还是持续应用浮点型好呢？

测试代码如下:

public void convertAndValiddInt(long value) {    //test中其余相似办法定义与其类似，只须要扭转set和get办法    //1.通过build创立音讯结构器    MyTest.Data.Builder dataBuilder = MyTest.Data.newBuilder();    //2.设置字段值    dataBuilder.setInt64(value);    //3.通过音讯结构器结构音讯对象    MyTest.Data data = dataBuilder.build();    //4.序列化    byte[] bytes = data.toByteArray();    System.out.println(value+"序列化后的数据：" + Arrays.toString(bytes)+",字节个数："+bytes.length);    //5.反序列化    try {        MyTest.Data parseFrom = MyTest.Data.parseFrom(bytes);        System.out.println("反序列化后的数据="+parseFrom.getInt64());    } catch (InvalidProtocolBufferException e) {        e.printStackTrace();    }}    @Testpublic void test(){    System.out.println("================若保留7位小数（准确到厘米）===============");    System.out.println("--> 转为整数，用int64编码：");    convertAndValiddInt(1700000001);    System.out.println("--> 仍用小数，用float编码：");    convertAndValiddFloat(170.0000001f);    System.out.println("--> 仍用小数，用double编码：");    convertAndValiddDouble(170.0000001);    System.out.println("================若保留8位小数（准确到毫米）===============");    System.out.println("--> 转为整数，用int64编码：");    convertAndValiddInt(Long.valueOf("17000000001"));    System.out.println("--> 仍用小数，用float编码：");    convertAndValiddFloat(170.00000001f);    System.out.println("--> 仍用小数，用double编码：");    convertAndValiddDouble(170.00000001);}

运行后果如下：

================若保留7位小数（准确到厘米）===============--> 转为整数，用int64编码：1700000001序列化后的数据：[32, -127, -30, -49, -86, 6],字节个数：6反序列化后的数据=1700000001--> 仍用小数，用float编码：170.0序列化后的数据：[93, 0, 0, 42, 67],字节个数：5反序列化后的数据=170.0--> 仍用小数，用double编码：170.0000001序列化后的数据：[97, -27, -81, 53, 0, 0, 64, 101, 64],字节个数：9反序列化后的数据=170.0000001================若保留8位小数（准确到毫米）===============--> 转为整数，用int64编码：17000000001序列化后的数据：[32, -127, -44, -99, -86, 63],字节个数：6反序列化后的数据=17000000001--> 仍用小数，用float编码：170.0序列化后的数据：[93, 0, 0, 42, 67],字节个数：5反序列化后的数据=170.0--> 仍用小数，用double编码：170.00000001序列化后的数据：[97, 100, 94, 5, 0, 0, 64, 101, 64],字节个数：9反序列化后的数据=170.00000001

【小结】
1、Float表白经纬度有损失（至多保留7位小数的状况下）。
2、对于经纬度等浮点数，将其转为整型数据，用int64编码更省空间。

3.5 工夫戳数据试验

很多场景会用到工夫戳，选用什么类型呢？
测试代码如下:

@Testpublic void testTime(){    System.out.println("================测试工夫戳(准确到秒)===============");    System.out.println("--> 用int64编码：");    convertInt64(Long.valueOf("1600229610283"));    System.out.println("--> 用fixed64编码：");    convertFixed64(Long.valueOf("1600229610283"));    System.out.println("================测试工夫戳(准确到毫秒)===============");    System.out.println("--> 用int64编码：");    convertInt64(Long.valueOf("1600229610283000"));    System.out.println("--> 用fixed64编码：");    convertFixed64(Long.valueOf("1600229610283000"));}

运行后果如下：

================测试工夫戳(准确到秒)===============--> 用int64编码：1600229610283序列化后的数据：[32, -85, -90, -8, -88, -55, 46],字节个数：7--> 用fixed64编码：1600229610283序列化后的数据：[65, 43, 19, 30, -107, 116, 1, 0, 0],字节个数：9================测试工夫戳(准确到毫秒)===============--> 用int64编码：1600229610283000序列化后的数据：[32, -8, -65, -21, -21, -25, -20, -21, 2],字节个数：9--> 用fixed64编码：1600229610283000序列化后的数据：[65, -8, -33, 122, 125, 102, -81, 5, 0],字节个数：9

【小结】
对于工夫戳，倡议用int64编码。

4 总结

对于整型数据：

1、若有正数，倡议应用sint。
2、若全为负数，则uint、int、sint均可，但sint多算了zigzag编码，减少了计算。倡议默认应用int，很可能有正数时用sint。
3、若大数值占比大，则应用fixed32或fixed64。

对于字符串数据：避免出现中文。

对于工夫戳：倡议用int64编码。

对于坐标等浮点数：倡议将其转为整型数据，用int64编码

5 参考文献

【1】https://www.cnblogs.com/lvmf/...

【2】https://www.cnblogs.com/onlys...

【3】https://zhuanlan.zhihu.com/p/...

【4】https://www.zhihu.com/questio...

【5】https://developers.google.com...