透过byte数组简单分析Java序列化、Kryo、ProtoBuf序列化

序列化在高性能网络编程、分布式系统开发中是举足轻重的之前有用过Java序列化、ProtocolBuffer等，在这篇文章这里中简单分析序列化后的byte数组观察各种序列化的差异与性能，这里主要分析Java序列化、Kryo、ProtocolBuffer序列化；

• Java序列化为jdk自带的序列化实现，不需要依赖任何包；
  
• Kryo为高性能开源的Java第三方序列化框架
  
• ProtocolBuffer为google开源的数据交换格式，独立于语言，支持Java、Python、C++、C#等

比较性能

说明：使用Java序列化、Kryo、ProtocolBuffer分别序列化、反序列化十万次比较三种方式分别使用的时间；

入口程序：

public class TestData implements Serializable {
int sn; 
public void setSn(int sn) {
    this.sn = sn;
  } 
}

public class SerializeCompare {

public static void main(String[] args){
    TestData testData=new TestData();
    testData.setSn(10);

    SerializeCompare serialize = new SerializeCompare();
    try {
        serialize.jdkSerialize(testData);
        System.out.println("---------------------------------------------------------------");
        serialize.kryoTest(testData);
        System.out.println("---------------------------------------------------------------");
        serialize.protocolTest(); 

    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void jdkSerialize(TestData testData) throws IOException,
        ClassNotFoundException {
    JdkSerialize jdkSerialize = new JdkSerialize();
    byte[] jdkByte = null;
    TestData deSerialize = null;
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        jdkByte = jdkSerialize.serialize(testData);
        deSerialize = (TestData) jdkSerialize.deSerialize(jdkByte);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("jdk serialize:" + (endTime - startTime) + "ms"); 
}

public void kryoTest(TestData testData) {
    KryoSerialize kryoSerialize = new KryoSerialize();
    byte[] kryoByte = null;
    TestData kryObj = null;
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        kryoByte = kryoSerialize.serialize(testData);
        kryObj = (TestData) kryoSerialize.deSerialize(kryoByte);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("kryo serialize:" + (endTime - startTime) + "ms"); 
}

public void protocolTest(){

    TestDataProto.TestData.Builder testData=TestDataProto.TestData.newBuilder();
    testData.setSn(8); 
    byte[] datas = null； 
    TestDataProto.TestData temp = null;
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        datas = testData.build().toByteArray();
        try {
            temp =TestDataProto.TestData.parseFrom(datas);
        } catch (InvalidProtocolBufferException e) {
            e.printStackTrace();
        }
    }
    long endTime = System.currentTimeMillis();
    System.out.println("protocol serialize:" + (endTime - startTime) + "ms"); 

}
}

　　对比结果发现Java序列化的性能相比其他两种慢了好多，程序跑多次取中间值，java序列化花的时间为kryo的6倍、为ProtoclBuffer的30多倍，kryo相差也是为6倍左右。

程序跑完的结果：

  
jdk serialize:1259ms
byte length : 68
ac ed 00 05 73 72 00 26 63 6f 2e 73 6f 6c 69 6e 78 2e 64 65 6d 6f 2e 73 65 72 69 61 6c 69 7a 65 2e 64 61 74 61 2e 54 65 73 74 44 61 74 61 4f 17 51 92 bb 30 95 54 02 00 01 49 00 02 73 6e 78 70 00 00 00 0a
---------------------------------------------------------------  
kryo serialize:259ms
byte length : 42
01 00 63 6f 2e 73 6f 6c 69 6e 78 2e 64 65 6d 6f 2e 73 65 72 69 61 6c 69 7a 65 2e 64 61 74 61 2e 54 65 73 74 44 61 74 e1 01 14
---------------------------------------------------------------  
protocol serialize:44ms
byte length : 2
08 08

分析byte数组

　　三种序列化中Java序列化的字节数组是最长的，kryo稍微比Java序列化短一点而ProtocolBuffer的字节数组只有两个字节，下面具体分析每个byte数组；
Java序列化的byte数组
ac ed 00 05 73 72 00 26 63 6f 2e 73 6f 6c 69 6e 78 2e 64 65 6d 6f 2e 73 65 72 69 61 6c 69 7a 65 2e 64 61 74 61 2e 54 65 73 74 44 61 74 61 4f 17 51 92 bb 30 95 54 02 00 01 49 00 02 73 6e 78 70 00 00 00 0a
Java序列化后字节数组三部分组成：开头、类描述、字段值，byte数组中包含了类的版本、元数据、字段描述，字段值等；

开头，所有的对象序列化后都会有，开头与类的描述标识都有在ObjectStreamConstants类中定义有常量；
ac ed ： 为幻数
00 05 ： 流的版本
类描述

73 ： TC_OBJECT 新对象
72 ： 新类描述
00 26 ： 类名长度
63 6f 2e 73 6f 6c 69 6e 78 2e 64 65 6d 6f 2e 73 65 72 69 61 6c 69 7a 65 2e 64 61 74 61 2e 54 65 73 74 44 61 74 61 ：类名 co.solinx.demo.serialize.data.TestData
4f 17 51 92 bb 30 95 54 ： serialVersionUID的值
02 ： 表示对象支持序列化
00 01 ： 表示字段的个数
49 ： ASCII码为I，表示字段为int类型
00 02 ： 字段名称长度
73 6e ： 字段名称：sn
78 ： 对象块结束标志,TC ENDBLOCKDATA
70 ： 没有父类 TC NULL

00 00 00 0a ： 字段sn的值

kryo序列化的byte数组
01 00 63 6f 2e 73 6f 6c 69 6e 78 2e 64 65 6d 6f 2e 73 65 72 69 61 6c 69 7a 65 2e 64 61 74 61 2e 54 65 73 74 44 61 74 e1 01 14
Kryo序列化要比Java序列化简单很多，只有标识+类名+字段三部分组成，对String使用最后一位byte+X70标识String结束；

01 00 ： 标识
63 6f 2e 73 6f 6c 69 6e 78 2e 64 65 6d 6f 2e 73 65 72 69 61 6c 69 7a 65 2e 64 61 74 61 2e 54 65 73 74 44 61 74 e1 ： 类的名称类名 co.solinx.demo.serialize.data.TestData
01 ： 一个字段
14 ： 字段的值，反序列化通过 14 >>> 1 ^ -(14 & 1)可以得到值

ProtocolBuffer序列化的byte数组
08 08
　　ProtoBuf序列化后只有两个字节，跟前面两种简直没法比，但ProtoBuf和其他两种的序列化区别很大，ProtoBuf为与语言平台无关的，需要编写自定义的proto文件定义数据格式，然后用ProtoBuf编译器编译成目标语言：C++、Java、Python等的代理类，对象的序列化、反序列化都需要使用该类来完成；
　　ProtoBuf序列化对象的byte数组由一系列的key-Value组成，key计算公式为：(field_number<<3)|wire_type、Value：经过编码后的byte，ProtoBuf使用了Varint、zigzag编码极大的压缩了序列化后byte数组的大小，所以当前我们看到的byte数组只有08 08 两个字节。
08 ： 为key，使用(1<<3)|0计算得到
08 ： 为字段sn经过Varint编码后的值

总结

　　Java序列化相比Kryo与ProtoBuf序列化后的数组要打得多，速度也慢很多，Java序列化时没有对byte经过任何处理，而且序列化类的元素也太多有：开头、类描述、字段值，类的版本、元数据、字段描述，字段值等这些组成，这也是他byte数组大，速度慢的主要原因；
　　Kryo序列化后只有类名和字段信息，相比Java序列化就要简单了不少，而且Kryo对int、long使用了变长存储也节省了不少空间；
　　ProtoBuf序列化后的byte只有key-value对组成还使用了Varint、zigzag编码，速度极快，而且占用的空间也极少，但是由于ProtoBuf要编写数据定义文件还要使用ProtoBuf编译器生成目标语言对象，所以相对Java序列化与Kryo来说会麻烦一点；
　　用哪种序列化组件主要要是主要取决于需求，如果对跨语言、性能要求比较高、新旧版本兼容要求那这三种中ProtoBuf是不二的选择，如果不要求跨语言对性能又有一定要求那Kryo是不错的选择，如果不跨语言对性能、空间也没有要求那可以选择Java序列化；
　　文章首发地址：Solinx
　　http://www.solinx.co/archives/377