写点什么

优化技术专题 - 性能优化系列 - 针对 Java 对象压缩及序列化技术的探索之路

发布于: 刚刚
优化技术专题-性能优化系列-针对Java对象压缩及序列化技术的探索之路

序列化和反序列化

  • 序列化就是指把对象转换为字节码;

  • 对象传递和保存时,保证对象的完整性和可传递性。把对象转换为有字节码,以便在网络上传输或保存在本地文件中;

  • 反序列化就是指把字节码恢复为对象;

  • 根据字节流中保存的对象状态及描述信息,通过反序列化重建对象;

  • 一般情况下要求实现 Serializable 接口,该接口中没有定义任何成员,只是起到标记对象是否可以被序列化的作用。

  • 对象在进行序列化和反序列化的时候,必须实现 Serializable 接口,但并不强制声明唯一的 serialVersionUID,是否声明 serialVersionUID 对于对象序列化的向上向下的兼容性有很大的影响。

为何需要有序列化呢?

  • 一方面是为了存储在磁盘中

  • 另一方面为了网络远程传输的内容

Java 实现序列化的方式

二进制格式 + 指定语言层级

JavaBuiltIn(java 原生)、JavaManual(根据成员变量类型,手工写)、FstSerliazation、Kryo

二进制格式 + 跨语言层级

Protobuf(Google)、Thrift(Facebook)、 AvroGeneric、Hessian

JSON 格式化

Jackson、Gson、FastJSON 等

类 JSON 格式化:

CKS (textual JSON-like format)、BSON(JSON-like format with extended datatypes)、JacksonBson、MongoDB

XML 文件格式化

XmlXStream 等

序列化的分类

序列化工具大致就可以分为以上几类,简单概括就分为二进制 binary 和文本格式(json、xml)两大类。

在速度的对比上一般有如下规律:

  • binary > textual

  • language-specific > language-unspecific


而 textual 中,由 json 相比 xml 冗余度更低因此速度上更胜一筹,而 json 又比 bson 这类 textual serialization 技术上更成熟,框架的选择上更丰富和优秀。


下面重点介绍下 Kryo、fast-serialiation、fastjson、protocol-buffer

Java 原生序列化(青铜级别)

  • Java 本身提供的序列化工具基本上能胜任大多数场景下的序列化任务,关于其序列化机制。

  • 需要类实现了 Serializable 或 Externalizable 接口,否则会抛出异常,然后使用 ObjectOutputStream 与 ObjectInputStream 将对象写入写出。

  • Java 自带的序列化工具在序列化过程中需要不仅需要将对象的完整的 class name 记录下来,还需要把该类的定义也都记录下,包括所有其他引用的类,这会是一笔很大的开销,尤其是仅仅序列化单个对象的时候。

  • 正因为 java 序列化机制会把所有 meta-data 记录下来,因此当修改了类的所在的包名后,反序列化则会报错。


 //对象转成字节码 ByteArrayOutputStream byteArrayOutputStream = new  ByteArrayOutputStream(); ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream); outputStream.writeObject(VoUtil.getUser()); byte  []bytes = byteArrayOutputStream.toByteArray(); outputStream.close(); //字节码转换成对象 ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes); ObjectInputStream inputStream = new ObjectInputStream(byteArrayInputStream); Model result = (Model) inputStream.readObject(); inputStream.close();
复制代码

Kryo 序列化框架(星耀级别)

  • kryo 根据上述 Java 原生序列化机制的一些问题,对了很多优化工作,而且提供了很多 serializer,甚至封装了 Unsafe 类型的序列化方式,更多关于 Unsafe 类型的序列化方式。

  • kryo,是一个快速序列化/反序列化工具,效率比 java 高出一个级别,序列化出来的结果,是其自定义的、独有的一种格式,体积更小,一般只用来进行序列化和反序列化,而不用于在多个系统、甚至多种语言间进行数据交换(目前 kryo 也只有 java 实现),目前已经有多家大公司使用,相对比较稳定。


    <dependency>        <groupId>com.esotericsoftware</groupId>        <artifactId>kryo</artifactId>        <version>4.0.0</version>      </dependency> 
复制代码

KryoUtils 序列化和反序列化操作

Kryo 有三组读写对象的方法
  • 如果不知道对象的具体类,且对象可以为 null:


kryo.writeClassAndObject(output, object);Object object = kryo.readClassAndObject(input);
复制代码


  • 如果类已知且对象可以为 null:


kryo.writeObjectOrNull(output, someObject);SomeClass someObject = kryo.readObjectOrNull(input, SomeClass.class);
复制代码


  • 如果类已知且对象不能为 null:


kryo.writeObject(output, someObject);SomeClass someObject = kryo.readObject(input, SomeClass.class);
复制代码

序列化和反序列化操作工具类 KryoUtils

Kryo 和 KryoRegister

Kryo 的运行速度是 java Serializable 的 20 倍左右 Kryo 的文件大小是 java Serializable 的一半左右

Kryo 有两种模式:

一种是先注册(regist),再写对象,即 writeObject 函数,实际上如果不先注册,在写对象时也会注册,并为 class 分配一个 id。


注意,跨进程,则必须两端都按同样的模式,否则会出错,因为必须要明确类对应的唯一 id。


另一种是写类名及对象,即 writeClassAndObject 函数。


writeClassAndObject 函数是先写入一个约定的数字,再写入类 ID(第一次要先写-1,再写类 ID + 类名),写入引用关系,最后才写真正的数据。

Kryo 的操作模式


static Kryo kryo = new Kryo();
public static byte[] serialize(Object obj) { byte[] buffer = new byte[2048]; Output output = new Output(buffer); kryo.writeClassAndObject(output, obj); byte[] bs = output.toBytes(); output.close(); return bs;}
public static Object deserialize(byte[] src) { Input input = new Input(src); Object obj = kryo.readClassAndObject(input); input.close(); return obj;}
复制代码

Kryo 的 Register 操作模式


static Kryo kryo = null;static{ kryo = new Kryo(); kryo.setReferences(false); kryo.setRegistrationRequired(false); kryo.setInstantiatorStrategy(new StdInstantiatorStrategy());}
public static byte[] serialize(Object obj) { kryo.register(obj.getClass()); byte[] buffer = new byte[2048]; Output output = new Output(buffer); kryo.writeObject(output, obj); byte[] bs = output.toBytes(); output.close(); return bs;}
public static Object deserialize(byte[] src, Class<?> clazz) { kryo.register(clazz); Input input = new Input(src); Object obj = kryo.readObject(input, clazz); input.close(); return obj;}
复制代码


推荐:https://blog.csdn.net/fanjunjaden/article/details/72823866


借鉴网上的一个很不错的工具类!


public class KryoUtils  {    /**     * (池化Kryo实例)使用ThreadLocal     */    private static final ThreadLocal<Kryo> kryos = new ThreadLocal<Kryo>() {        @Override        protected Kryo initialValue() {            Kryo kryo = new Kryo();            //支持对象循环引用(否则会栈溢出)            kryo.setReferences(true);            // 不强制要求注册类(注册行为无法保证多个 JVM 内同一个类的注册编号相同;      // 而且业务系统中大量的 Class 也难以一一注册)            kryo.setRegistrationRequired(false);             //Fix the NPE bug when deserializing Collections.            kryo.setInstantiatorStrategy(new StdInstantiatorStrategy());            return kryo;        }    };    /**     * (池化Kryo实例)使用KryoPool     */    private static KryoFactory factory = new KryoFactory() {        public Kryo create () {            Kryo kryo = new Kryo();            return kryo;        }    };    private static KryoPool pool = new KryoPool.Builder(factory).softReferences().build();    /**     * 使用ThreadLocal创建Kryo     * 把java对象序列化成byte[];     * @param obj java对象     * @return     */    public static <T>  byte[] serializeObject(T obj) {        ByteArrayOutputStream os=null;        Output output=null;        if(null != obj){            Kryo kryo = kryos.get();            try {                os = new ByteArrayOutputStream();                output = new Output(os);                kryo.writeObject(output, obj);                close(output);                return os.toByteArray();            } catch (Exception e) {                e.printStackTrace();            }finally {                close(os);            }        }        return null;    }
/** * 使用ThreadLocal创建Kryo * 把byte[]反序列化成指定的java对象 * @param bytes * @param t 指定的java对象 * @param <T> * @return 指定的java对象 */ public static <T> T unSerializeObject(byte[] bytes,Class<T> t) { ByteArrayInputStream is=null; Input input=null; if(null != bytes && bytes.length>0 && null!=t){ try { Kryo kryo = kryos.get(); is = new ByteArrayInputStream(bytes); input = new Input(is); return kryo.readObject(input,t); } catch (Exception e) { e.printStackTrace(); }finally { close(is); close(input); } } return null; }
/** * 使用ThreadLocal创建Kryo * 把List序列化成byte[]; * @param list java对象 * @return */ public static <T> byte[] serializeList(List<T> list ) { ByteArrayOutputStream os=null; Output output=null; byte[] bytes = null; if(null != list && list.size()>0){ Kryo kryo = kryos.get(); try { os = new ByteArrayOutputStream(); output = new Output(os); kryo.writeObject(output,list); close(output); bytes = os.toByteArray(); return bytes; } catch (Exception e) { e.printStackTrace(); }finally { close(os); } } return null; } /** * 使用ThreadLocal创建Kryo * 把byte[]反序列化成指定的List<T> * @param bytes byte数组 * @param <T> * @return 指定java对象的List */ public static <T> List<T> unSerializeList(byte[] bytes) { ByteArrayInputStream is=null; Input input=null; if(null !=bytes && bytes.length>0){ try { Kryo kryo = kryos.get(); is = new ByteArrayInputStream(bytes); input = new Input(is); List<T> list = kryo.readObject(input,ArrayList.class); return list; } catch (Exception e) { e.printStackTrace(); }finally { close(is); close(input); } } return null; } /** * 使用ThreadLocal创建Kryo * 把java对象转序列化存储在文件中; * @param obj java对象 * @return */ public static <T> boolean serializeFile(T obj,String path) { if(null != obj){ Output output=null; try { Kryo kryo = kryos.get(); output = new Output(new FileOutputStream(path)); kryo.writeObject(output, obj); return true; } catch (Exception e) { e.printStackTrace(); }finally { close(output); } } return false; } /** * 使用ThreadLocal创建Kryo * 把序列化的文件反序列化成指定的java对象 * @param path 文件路径 * @param t 指定的java对象 * @param <T> * @return 指定的java对象 */ public static <T> T unSerializeFile(String path,Class<T> t) { if(null != path && null !=t ){ Input input=null; try { Kryo kryo = kryos.get(); input = new Input(new FileInputStream(path)); return kryo.readObject(input,t); } catch (Exception e) { e.printStackTrace(); }finally { close(input); } } return null; } /** * 使用KryoPool SoftReferences创建Kryo * 把java对象序列化成byte[] ; * @param obj java对象 * @return */ public static <T> byte[] serializePoolSoftReferences (T obj) { if(null!=obj){ Kryo kryo =pool.borrow(); ByteArrayOutputStream os=null; Output output=null; try { os = new ByteArrayOutputStream(); output = new Output(os); kryo.writeObject(output, obj); close(output); byte [] bytes = os.toByteArray(); return bytes; } catch (Exception e) { e.printStackTrace(); }finally { pool.release(kryo); close(os); } } return null; } /** * 使用KryoPool SoftReferences创建Kryo * 把byte[]反序列化成指定的java对象 * @param bytes * @return */ public static <T> T unSerializePoolSoftReferences(byte[] bytes,Class<T> t) { if(null !=bytes && bytes.length>0 && null!=t){ Kryo kryo =pool.borrow(); ByteArrayInputStream is=null; Output output=null; try { is = new ByteArrayInputStream(bytes); Input input= new Input(is); return kryo.readObject(input, t); } catch (Exception e) { e.printStackTrace(); }finally { pool.release(kryo); close(is); close(output); } } return null; } /** * 使用KryoPool SoftReferences创建Kryo * 把java对象序列化成byte[] ; * @param obj java对象 * @return */ public static <T> byte[] serializePoolCallback (final T obj) { if(null != obj){ try { return pool.run(new KryoCallback<byte[]>() { public byte[] execute(Kryo kryo) { ByteArrayOutputStream os = new ByteArrayOutputStream(); Output output = new Output(os); kryo.writeObject(output,obj); output.close(); try { os.close(); } catch (IOException e) { e.printStackTrace(); } return os.toByteArray(); } }); } catch (Exception e) { e.printStackTrace(); } } return null; } /** * 使用KryoPool SoftReferences创建Kryo * 把byte[]反序列化成指定的java对象 * @param bytes * @return */ public static <T> T unSerializePoolCallback(final byte[] bytes, final Class<T> t) { if(null != bytes && bytes.length>0 && null != t){ try { return pool.run(new KryoCallback<T>() { public T execute(Kryo kryo) { ByteArrayInputStream is = new ByteArrayInputStream(bytes); Input input = new Input(is); T result =kryo.readObject(input,t); input.close(); try { is.close(); } catch (IOException e) { e.printStackTrace(); } return result; } }); } catch (Exception e) { e.printStackTrace(); } } return null; } /** * 关闭io流对象 * * @param closeable */ public static void close(Closeable closeable) { if (closeable != null) { try { closeable.close(); } catch (Exception e) { e.printStackTrace(); } } }
复制代码


参考官方文档:https://github.com/EsotericSoftware/kryo

FST 序列化机制(钻石级别)

  • FST(Fast-serialization-Tool),与 kryo 类似是 apache 组织的一个开源项目,完全兼容 JDK 序列化协议的系列化框架,序列化速度大概是 JDK 的 4-10 倍,体积更小,大小是 JDK 大小 1/3 左右,重新实现的 Java 快速对象序列化的开发包。

  • 相对来说是一个很新的序列化工具,速度于 kryo 有一些差距,在生产环境上的场景上测试,效果几乎于 kryo 一致,都能瞬间反序列化出内容并渲染。


Java 快速序列化库 FST 已经发布了 2.0 版本,该版本的包名已经更改,无法平滑升级。另外官方建议为了稳定性考虑还是使用最新的 1.58 版本为好

Maven 配置

<dependency>        <groupId>de.ruedigermoeller</groupId>        <artifactId>fst</artifactId>        <version>1.58</version> </dependency> 
复制代码

案例代码

static FSTConfiguration configuration = FSTConfiguration           .createDefaultConfiguration();
public static byte[] serialize(Object obj){ return configuration.asByteArray((Serializable)obj);}public static Object deserialize(byte[] sec){ return configuration.asObject(sec);}
复制代码


官方文档: https://github.com/RuedigerMoeller/fast-serialization/wiki/Serialization

protostuff(王者级别)

Protocol buffers 是一个用来序列化结构化数据的技术,支持多种语言诸如 C++、Java 以及 Python 语言,可以使用该技术来持久化数据或者序列化成网络传输的数据。相比较一些其他的 XML 技术而言,该技术的一个明显特点就是更加节省空间(以二进制流存储)、速度更快以及更加灵活。


protostuff,是 google 在原来的 protobuffer 是的优化产品。使用起来也比较简单易用,目前效率也是最好的一种序列化工具。


 <dependency>        <groupId>io.protostuff</groupId>        <artifactId>protostuff-core</artifactId>        <version>1.4.0</version>      </dependency>      <dependency>        <groupId>io.protostuff</groupId>        <artifactId>protostuff-runtime</artifactId>        <version>1.4.0</version>      </dependency> 
复制代码
protostuff 工具类
public class ProtostuffUtil {     public static <T> byte[] serializer(T t){        Schema schema = RuntimeSchema.getSchema(t.getClass());        return ProtostuffIOUtil.toByteArray(t,schema,                LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));     }
public static <T> T deserializer(byte []bytes,Class<T> c) { T t = null; try { t = c.newInstance(); Schema schema = RuntimeSchema.getSchema(t.getClass()); ProtostuffIOUtil.mergeFrom(bytes,t,schema); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } return t; }}
复制代码

Fastjson(钻石)

一个 JSON 库涉及的最基本功能就是序列化和反序列化。Fastjson 支持 java bean 的直接序列化。 使用 com.alibaba.fastjson.JSON 这个类进行序列化和反序列化。


public static String serialize(Object obj){    String json = JSON.toJSONString(obj);    return json;}public static Object deserialize(String json, Class<?> clazz){    Object obj = JSON.parseObject(json, clazz);    return obj;}
复制代码
Maven 配置
 <dependency>        <groupId>com.alibaba</groupId>        <artifactId>fastjson</artifactId>        <version>1.2.47</version>   </dependency> 
复制代码

Gson(钻石)

这里采用 JSON 格式同时使用采用 Google 的 gson 进行转义.


static Gson gson = new Gson();
public static String serialize(Object obj){ String json = gson.toJson(obj); return json;}public static Object deserialize(String json, Class<?> clazz){ Object obj = gson.fromJson(json, clazz); return obj;}
复制代码

Jackson(铂金)

Jackson 库(http://jackson.codehaus.org),是基于 java 语言的开源 json 格式解析工具,整个库(使用最新的 2.2 版本)包含 3 个 jar 包:


  • jackson-core.jar——核心包(必须),提供基于“流模式”解析的 API。

  • jackson-databind——数据绑定包(可选),提供基于“对象绑定”和“树模型”相关 API。

  • jackson-annotations——注解包(可选),提供注解功能。


性能较高,“流模式”的解析效率超过绝大多数类似的 json 包。核心包:JsonParser(json 流读取),JsonGenerator(json 流输出)。数据绑定包:ObjectMapper(构建树模式和对象绑定模式),JsonNode(树节点)


public static String serialize(Object obj){    ObjectMapper mapper = new ObjectMapper();    String json = null;    try {        json = mapper.writeValueAsString(obj);    } catch (Exception e) {        // TODO Auto-generated catch block        e.printStackTrace();    }    return json;}public static Object deserialize(String json, Class<?> clazz){    ObjectMapper mapper = new ObjectMapper();    Object obj = null;    try {        obj = mapper.readValue(json, clazz);    } catch (Exception e) {        // TODO Auto-generated catch block        e.printStackTrace();    }    return obj;}
复制代码


下表是几种方案的各项指标的一个对比



发布于: 刚刚阅读数: 2
用户头像

🏆 2021年InfoQ写作平台-签约作者 🏆 2020.03.25 加入

【个人简介】酷爱计算机技术、醉心开发编程、喜爱健身运动、热衷悬疑推理的”极客狂人“ 【技术格言】任何足够先进的技术都与魔法无异 【技术范畴】Java领域、Spring生态、MySQL专项、APM专题及微服务/分布式体系等

评论

发布
暂无评论
优化技术专题-性能优化系列-针对Java对象压缩及序列化技术的探索之路