Java常见的序列化和反序列化框架的性能，速度，大小pk

最新推荐文章于 2024-08-18 20:56:28 发布

愤怒哥

最新推荐文章于 2024-08-18 20:56:28 发布

阅读量2.2k

点赞数

分类专栏： protocol 文章标签： java protobuf 序列最小化优化算法 rpc kryo

本文链接：https://blog.csdn.net/u011327159/article/details/117844171

版权

protocol 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

在很长的一段时间，kryo都是Java环境最快的序列化框架，也得到了广泛的应用。

最近出现的zfoo protocol是新进的挑战者，于是就分别测试了，zfoo，kryo，protobuf的速度，性能，大小。

序列化：将Java对象转化为二进制的byte字节数组
反序列化：将二进制的byte字节数组转化为Java对象

在RPC应用中，进行跨进程远程调用的时候，需要使用特定的序列化技术，需要对进行网络传输的对象进行序列化和反序列化。

影响序列化和反序列化选择有两个主要因素

1.序列化之后码流的大小，如果太大，那么将会影响网络传输的性能。
2.序列化和反序列化过程的性能

本文主要从性能和序列化过后的大小做测试

Ⅰ. 性能测试

测试环境
测试代码地址

操作系统：win10 cpu： i9900k 内存：64g

在这里插入图片描述

Ⅱ. 序列化和反序列化大小

简单对象，zfoo包体大小8，kryo包体大小5，protobuf包体大小8
常规对象，zfoo包体大小547，kryo包体大小594，protobuf包体大小984
复杂对象，zfoo包体大小2214，kryo包体大小2525，protobuf包体大小5091

Ⅲ. 对象定义

简单对象

public class SimpleObject implements IPacket {

    public static final transient short PROTOCOL_ID = 1163;

    private int c;
    private boolean g;
}

普通对象

public class NormalObject implements IPacket {

    public static final transient short PROTOCOL_ID = 1161;

    private byte a;
    private byte[] aaa;
    private short b;
    private int c;
    private long d;
    private float e;
    private double f;
    private boolean g;
    private String jj;
    private ObjectA kk;

    private List<Integer> l;
    private List<Long> ll;
    private List<ObjectA> lll;
    private List<String> llll;

    private Map<Integer, String> m;
    private Map<Integer, ObjectA> mm;

    private Set<Integer> s;
    private Set<String> ssss;
}

复杂对象

public class ComplexObject implements IPacket {

    public static final transient short PROTOCOL_ID = 1160;

    private byte a;
    private Byte aa;
    private byte[] aaa;
    private Byte[] aaaa;

    private short b;
    private Short bb;
    private short[] bbb;
    private Short[] bbbb;

    private int c;
    private Integer cc;
    private int[] ccc;
    private Integer[] cccc;

    private long d;
    private Long dd;
    private long[] ddd;
    private Long[] dddd;

    private float e;
    private Float ee;
    private float[] eee;
    private Float[] eeee;

    private double f;
    private Double ff;
    private double[] fff;
    private Double[] ffff;

    private boolean g;
    private Boolean gg;
    private boolean[] ggg;
    private Boolean[] gggg;

    private char h;
    private Character hh;
    private char[] hhh;
    private Character[] hhhh;

    private String jj;
    private String[] jjj;
    private ObjectA kk;
    private ObjectA[] kkk;


    private List<Integer> l;
    private List<List<List<Integer>>> ll;
    private List<List<ObjectA>> lll;
    private List<String> llll;
    private List<Map<Integer, String>> lllll;

    private Map<Integer, String> m;
    private Map<Integer, ObjectA> mm;
    private Map<ObjectA, List<Integer>> mmm;
    private Map<List<List<ObjectA>>, List<List<List<Integer>>>> mmmm;
    private Map<List<Map<Integer, String>>, Set<Map<Integer, String>>> mmmmm;

    private Set<Integer> s;
    private Set<Set<List<Integer>>> ss;
    private Set<Set<ObjectA>> sss;
    private Set<String> ssss;
    private Set<Map<Integer, String>> sssss;
}