享学课堂作者：逐梦々少年
简书ID：逐梦々少年
转载请声明出处！
上次我们详细的学习了Java中的序列化机制，但是我们日常开发过程中，因为java的序列化机制的压缩效率问题，以及序列化大小带来的传输的效率问题，一般很少会使用原生的序列化机制，而是使用常见的序列化开源框架来实现序列化操作，接下来我们学习一下开发常用的序列化机制及原理分析
常见的序列化框架
xml序列化
在java发展早期开始，为了统一接口，xml协议横空出世，良好的可读性，*度极高的扩展性，成了很长一段时间的序列化标准规范。实现xml序列化/反序列化的方案有很多，最常见的是XStream 和 Java 自带的 XML 序列化和反序列化两种 ，并且还有基于xml协议的soap协议实现的webservice接口等。可以说xml序列化是开发中最常见也是发展时间最久的协议，并且支持跨进程和跨语言交互，但是缺陷也很明显，即xml规范下的每一个属性和值都是固定的标签形式，导致序列化后的字节流文件很大，远超于java自身的序列化方案，而且效率很低，一般建议使用在内部系统或者性能要求不高，但是对于接口的复杂度和准确性要求比较高的接口交互，或者适合多语言多进程之间交互的统一规范，不适合QPS过高的工程使用
JSON序列化
在xml序列化发展了多年后，也浮现了一些问题，比如开发并不简便，解析xml复杂度较高，还有xml的标准规范比较多，*度过高，导致很难有效的指定格式校验等，于是一种新的轻量级的序列化交互的方案–JSON（JavaScript Object Notation）出现了，相对于xml来说，json格式语法简单，*度较高，有很高的可读性，并且在JSON序列化后的字节流小于xml序列化的结果，解析起来更方便，于是基于JSON的接口成了新的标准规范之一，到现在也出现了很多JSON的序列化/反序列化的开源框架，比如开发中最常见到的Jackson、阿里巴巴开源的FastJson、谷歌的GSON等，而这三种框架各有优劣，通过测试一万个对象的序列化和反序列化的效率，对比如下:
序列化:
反序列化:
可以看出来序列化的时候，Gson的速度明显稍微慢了一些，Jackson反而最快，而在反序列化的时候，三个表现都很稳定，时间都差不多，但是当数据比较大的时候，测试结果又有所不同，测试结果和数据来自https://blog.csdn.net/Sword52888/article/details/81062575 提供的代码和脚本，可以得出对应结论:
- 1、 当数据小于 100K 的时候，建议使用 Gson
- 2、 当数据100K 与 1M 的之间时候，建议使用各个JSON引擎性能差不多
- 3、 当数据大与 1M 的时候，建议使用 JackSon 与 FastJson
而在稳定性上面，默认情况下Gson在各种情况下的表现最好，Jackson配合对应的配置化也能达到很好的稳定性，而FastJson表现的不稳定，所以对于这几种json库的使用，建议环境较复杂场景下使用JackSon，加上自定义的配置化可以更灵活的处理更多的场景，但是在复杂度一般，仅仅在乎性能的场景下，建议使用FastJson，因为FastJson的api更易用，依赖少，简单场景下使用简单
Hessian序列化
Hessian是一个支持跨语言传输的二进制文本序列化协议，对比Java默认的序列化，Hessian的使用较简单，并且性能较高，现在的主流远程通讯框架几乎都支持Hessian，比如Dubbo，默认使用的就是Hessian，不过是Hessian的重构版
Avro序列化
Avro序列化设计初衷是为了支持大批量数据交换的应用，支持二进制序列化方式，并且自身提供了动态语言支持，可以更加便捷、快速处理大批量的Avro数据
Kyro序列化
Kyro序列化是主流的比较成熟的序列化方案之一，目前广泛使用在大数据组件中，比如Hive、Storm等，性能比起Hessian还要优越，但是缺陷较明显，不支持跨语言交互，在dubbo2.6.x版本开始已经加入了Kyro序列化的支持
Protobuf序列化
Protobuf是谷歌提出的序列化方案，不同的是此方案独立于语言、平台，谷歌提供了多个语言如java、c、go、python等语言的实现，也提供了多平台的库文件支持，使用比较广泛，优点在于性能开销很小，压缩率很高，但是缺陷也很明显，可读性很差，并且protobuf需要使用特定语言的库进行翻译转换，使用起来较为麻烦
Protobuf序列化的使用
首先现在使用Protobuf，有手动编译和maven依赖jar两种方案，实际开发中我们一般使用maven坐标引入jar，坐标如下:
<dependency>
<groupId>com.dyuproject.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>1.0.8</version>
</dependency>
<dependency>
<groupId>com.dyuproject.protostuff</groupId>
<artifactId>protostuff-runtime</artifactId>
<version>1.0.8</version>
</dependency>
编写一个便捷的序列化转换工具类：
package com.demo.utils;
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtobufIOUtil;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
public class SerializeUtils{
/**
**序列化方法
*/
public static <T> byte[] serialize(T t,Class<T> clazz) {
return ProtobufIOUtil.toByteArray(t, RuntimeSchema.createFrom(clazz),
LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
}
/**
**反序列化方法
*/
public static <T> T deSerialize(byte[] data,Class<T> clazz) {
RuntimeSchema<T> runtimeSchema = RuntimeSchema.createFrom(clazz);
T t = runtimeSchema.newMessage();
ProtobufIOUtil.mergeFrom(data, t, runtimeSchema);
return t;
}
使用的时候直接使用工具类进行自动的转换传输即可
注：使用的时候注意jdk版本和jar版本的兼容问题，并且需要序列化的实体并不需要实现Serializable 接口
当然，我们接下来手动编译protobuf使用，了解下protobuf的语法以及原理
手动编译Protobuf
手动编译protobuf我们需要一个Protobuf编译器的支持，这里推荐直接点击地址，在github上下载:
https://github.com/google/protobuf/releases
或者直接百度云:http://pan.baidu.com/s/1gefsM9X 下载，这里博主选择直接百度云集成的环境下载
1:解压protoc-3.0.0-beta-2-win32会得到一个protoc.exe的文件.
2:解压protobuf-3.0.0-beta-2.(3.0.0-beta是版本号，可能会有所不同)
3.将protoc.exe文件放到2步骤解压后文件夹java/src/这个目录里面(src里面，不是跟src并级)
4.WINDOS+R 输入cmd命令并切换至3步骤的src目录的上级目录，就是java目录下会发现这个目录有个POM文件，使用maven编译命令编译(mvn install)，然后会在java目录下生成target以及一个jar。OK到目前位置，安装算完成了
接下来是编译环节，将上面生成的那个jar和一开始的那个exe文件放到需要编译文件的同一目录下 ，使用编译指令(cmd)：
protoc --java_out=xxx/xxx.proto
如果出现：Missing input file错误，那么就使用 以下指令:
protoc xxx/xxx.proto --java_out=./
接下来，我们开始编写一个protobuf的简单demo，后缀为proto,代码如下：
syntax="proto2";
package com.demo.serial;
option java_package = "com.demo.serial";
option java_outer_classname="UserProtos";
message User {
required string name=1;
required int32 age=2;
}
首先我们先看看上面编写的内容分别代表什么意思:
syntax=“proto2”;
这里指定了protobuf编译的版本，目前主流为proto2，当然也有不少选择最新的proto3版本，而每个大版本之间的差异还是很大的，具体区别参见官方说明:https://developers.google.com/protocol-buffers/docs/proto3
接着是:
option java_package = “com.demo.serial”
这里指定的是上一行我们设置的package对应java文件里面的package名称
option java_outer_classname=“UserProtos”
这里指定了如果编译完毕生成的java类的名称
message User
这里的message代表给User类指定对应属性类型
required string name=1
这里出现了一个特殊的修饰符类型required，在protobuf中，有如下几种修饰符:
- required: 格式良好的 message 必须包含该字段一次。
- optional: 格式良好的 message 可以包含该字段零次或一次（不超过一次）。
- repeated: 该字段可以在格式良好的消息中重复任意多次（包括零）。其中重复值的顺序会被保留。
注意：在proto3版本中，为了兼容性考虑，required修饰符已经取消
完成这些以后，我们使用指令:
protoc --java_out=xxx/xxx.proto
生成protobuf转换后的实体类，然后我们在pom中引入:
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf.java</artifactId>
<version>3.7.0</version>
</dependency>
然后进行序列化:
UserProtos.User user=UserProtos.User.newBuilder().setAge(300).setName("Mic").build();
byte[] bytes=user.toByteArray();
for(byte bt:bytes){
System.out.print(bt+" ");
}
我们将这个结果打印出来的字节如下:
10 3 77 105 99 16 -84 2
可以看出来序列化的数值看不明白，但是的确字节数很小，说明protobuf进行了算法压缩，那么我们就要了解下protobuf压缩算法相关的详细操作,首先我们要知道protobuf的type对应的各个语言的类型:
| .proto Type | Notes | C++ Type | Java Type | Python Type[2] | Go Type |
|---|---|---|---|---|---|
| double | double | double | float | *float64 | |
| float | float | float | float | *float32 | |
| int32 | 使用可变长度编码。编码负数的效率低 - 如果你的字段可能有负值，请改用 sint32 | int32 | int | int | *int32 |
| int64 | 使用可变长度编码。编码负数的效率低 - 如果你的字段可能有负值，请改用 sint64 | int64 | long | int/long[3] | *int64 |
| uint32 | 使用可变长度编码 | uint32 | int[1] | int/long[3] | *uint32 |
| uint64 | 使用可变长度编码 | uint64 | long[1] | int/long[3] | *uint64 |
| sint32 | 使用可变长度编码。有符号的 int 值。这些比常规 int32 对负数能更有效地编码 | int32 | int | int | *int32 |
| sint64 | 使用可变长度编码。有符号的 int 值。这些比常规 int64 对负数能更有效地编码 | int64 | long | int/long[3] | *int64 |
| fixed32 | 总是四个字节。如果值通常大于 228，则比 uint32 更有效。 | uint32 | int[1] | int/long[3] | *uint32 |
| fixed64 | 总是八个字节。如果值通常大于 256，则比 uint64 更有效。 | uint64 | long[1] | int/long[3] | *uint64 |
| sfixed32 | 总是四个字节 | int32 | int | int | *int32 |
| sfixed64 | 总是八个字节 | int64 | long | int/long[3] | *int64 |
| bool | bool | boolean | bool | *bool | |
| string | 字符串必须始终包含 UTF-8 编码或 7 位 ASCII 文本 | string | String | str/unicode[4] | *string |
| bytes | 可以包含任意字节序列 | string | ByteString | str | []byte |
Protobuf序列化的原理分析
了解了Protobuf的type转换的格式以后，我们再来看，Protobuf的存储格式，Protobuf采用了T-L-V的存储格式存储数据，其中的T代表tag，即key，L则是length，代表当前存储的类型的数据长度，当是数值类型的时候L被忽略，V代表value，即存入的值，protobuf会将每一个key根据不同的类型对应的序列化算法进行序列化，然后按照keyvaluekeyvalue的格式存储，其中key的type类型与对应的压缩算法关系如下:
| write_type | 编码方式 | type | 存储方式 |
|---|---|---|---|
| 0 | Varint(负数使用Zigzag辅助) | int32、int64、uint32、uint64、sint32、sint64、bool、enum | T-V |
| 1 | 64-bit | fixed、sfixed64、double | T-V |
| 2 | Length-delimi | string、bytes、embedded、messages、packed repeated fields | T-L-V |
| 3(弃用) | Start group | Groups(deprecated) | 弃用 |
| 4(弃用) | End group | Groups(deprecated) | 弃用 |
| 5 | 32-bit | fixed32、sfixed32、float | T-V |
需要注意的是protobuf的key计算按照**(field_number << 3) | wire_type** 方式计算，而这里的field_number是指定义的时候该字段的域号，如：required string name=1;这里的name字段的域号为1，在protobuf中规定:
- 如果域号在[1，15]范围内，会使用一个字节表示Key；
- 如果域号大于等于16，会使用两个字节表示Key；
key编码完成后，该字节的第一个比特位表示后一个字节是否与当前字节有关系，即:
- 如果第一个比特位为1，表示有关，即连续两个字节都是Key的编码；
- 如果第一个比特位为0，表示Key的编码只有当前一个字节，后面的字节是Length或者Value；
注意：protobuf中的域号定义要小于2048 ，原因为，最大的域号即2个字节16个比特位表示key，去掉位移的三位，还剩下13位，再去掉两个字节开头的第一个用来表示是否存在关系的比特位，即16-3-2=11，最后只有11位参与计算，二进制计算后2^11== 2048 ，所以域号不得超过2048
了解了以上的那些，我们看看，上述我们编写的案例，算法是如何实现的呢？
varint编码
上述我们的案例中，出现了int32类型，对应的压缩算法为varint，我们看下age=300，这个值是如何序列化的
可以看出来，我们首先将300转为二进制，结果为100101100，由于当前是int32，所以不足32位，高位全部补0，即为00000000000000000000000100101100，接着第二步，从低位到高位取7位，8位是一个字节，当前的最高位为标志位，如果下一个字节内还有非0得数值(即有意义存在)，则最高位补1，如果没有最高位补0，当最高位为0后，压缩存储结束，从age=300，我们可以看出来，取7位则是0101100，由于后一个字节中还存在值，所以最高位补1，则为10101100，而下一个字节则从第8位(低位到高位)开始，继续获取7个字节，则为0000010，由于后续的一个字节中，不存在有意义的值，则最高位补0，代表后续不存在有意义的值了，不需要继续压缩，则为00000010，也就是说原本32个比特位的数值，现在只有16个比特位，4个字节压缩到了2个字节，而我们都知道计算机中，高位为1代表负数，计算机中对负数的计算为先将结果取反后，再去补码操作，而负数的补码则是在反码的基础上+1，那么我们现在将结果反过来，先去-1，得到反码，则为10101011，再去取反，得到原码，则为01010100，现在我们将这个值转换为十进制，则可以知道结果为84，由于高位为1，则代表是负数，最终结果为-84，而00000010由于高位是0，代表本身为正数，正数的原码反码补码都是自身，所以直接转换为十进制结果为2，现在我们把这两个结果和上述打印的结果比较一下，是不是发现是一样的？当然，我们也从这个过程中发现了一些问题，比如小于128的值，我们甚至只需要1个字节就能存储完毕，但是如果我们需要存储的值很大，超过了268435455以后的数值，甚至需要五个字节来存储(超过28个有效比特位),但是绝大多数情况下，我们都不会使用这么大的数值，所以一般情况下，我们都能比之前使用更小的字节存储，达到压缩的目的
字符串压缩
在Protobuf中存储字符串格式，使用的T-L-V存储方式，标识符Tag采用Varint编码，字节长度Length采用Varint编码，string类型字段值采用UTF-8编码方式存储，所以tag得值为1 <<3 | 2 =10，L的值存储为00000011，即为3，而V的存储，把每一个字符按照UTF-8的编码后的字节流数组，分别为77 105 99，而在Protobuf编码后的字节流则是按照如图的顺序，所以打印出来的结果如上的10 3 77 105 99 16 -84 2
负数存储-write_type为0
在计算机中，负数会被表示为很大的整数，因为计算机定义负数符号位为数字的最高位，所
以如果采用 varint 编码表示一个负数，那么一定需要 5 个比特位。所以在 protobuf 中通过
sint32/sint64 类型来表示负数，负数的处理形式是先采用 zigzag 编码（把符号数转化为无符
号数），在采用 varint 编码。
sint32：(n << 1) ^ (n >> 31)
sint64：(n << 1) ^ (n >> 63)
比如存储一个（-300）的值
-300
原码：0001 0010 1100
取反：1110 1101 0011
加 1 ：1110 1101 0100
n<<1: 整体左移一位，右边补 0 -> 1101 1010 1000
n>>31: 整体右移 31 位，左边补 1 -> 1111 1111 1111
n<<1 ^ n >>31
1101 1010 1000 ^ 1111 1111 1111 = 0010 0101 0111
十进制： 0010 0101 0111 = 599
然后再使用varint 算法得到两个字节
1101 0111(-41),0000 0100(4)
总结
基于Protobuf序列化原理分析，为了有效降低序列化后数据量的大小，可以采用以下措施：
- 字段标识号（Field_Number）尽量只使用1-15，且不要跳动使用 Tag是需要占字节空间的。如果Field_Number>16时，Field_Number的编码就会占用2个字节，那么Tag在编码时就会占用更多的字节；如果将字段标识号定义为连续递增的数值，将获得更好的编码和解码性能
- 若需要使用的字段值出现负数，请使用sint32/sint64，不要使用int32/int64。 采用sint32/sint64数据类型表示负数时，会先采用Zigzag编码再采用Varint编码，从而更加有效压缩数据
- 对于repeated字段，尽量增加packed=true修饰 增加packed=true修饰，repeated字段会采用连续数据存储方式，即T - L - V - V -V方式
2.将结果赋值给a，则a = 3
public static void main(String[] args){
int a = 8;
a ^= 11;//a = 8^11 = 3
System.out.println(a);//3
}
面试结束复盘查漏补缺
每次面试都是检验自己知识与技术实力的一次机会，面试结束后建议大家及时总结复盘，查漏补缺，然后有针对性地进行学习，既能提高下一场面试的成功概率，还能增加自己的技术知识栈储备，可谓是一举两得。
以下最新总结的阿里P6资深Java必考题范围和答案，包含最全MySQL、Redis、Java并发编程等等面试题和答案，用于参考~
资料免费领取方式：点赞关注后，戳这里免费领取
重要的事说三遍，关注+关注+关注！
更多笔记分享
地进行学习，既能提高下一场面试的成功概率，还能增加自己的技术知识栈储备，可谓是一举两得。
以下最新总结的阿里P6资深Java必考题范围和答案，包含最全MySQL、Redis、Java并发编程等等面试题和答案，用于参考~
资料免费领取方式：点赞关注后，戳这里免费领取
重要的事说三遍，关注+关注+关注！
[外链图片转存中…(img-g8gsWO4V-1623741476500)]
[外链图片转存中…(img-DESmeLVZ-1623741476501)]
更多笔记分享