亦余心之所善兮，虽九死其犹未悔。这篇文章主要讲述Java技术专题「性能优化系列」针对Java对象压缩及序列化技术的探索之路相关的知识，希望能为你提供帮助。
序列化和反序列化

• 序列化就是指把对象转换为字节码；
  • 对象传递和保存时，保证对象的完整性和可传递性。把对象转换为有字节码，以便在网络上传输或保存在本地文件中；
• 反序列化就是指把字节码恢复为对象；
  
  • 根据字节流中保存的对象状态及描述信息，通过反序列化重建对象；
• 一般情况下要求实现Serializable接口，该接口中没有定义任何成员，只是起到标记对象是否可以被序列化的作用。
  • 对象在进行序列化和反序列化的时候，必须实现Serializable接口，但并不强制声明唯一的serialVersionUID，是否声明serialVersionUID对于对象序列化的向上向下的兼容性有很大的影响。

为何需要有序列化呢？

• 一方面是为了存储在磁盘中，
• 另一方面为了网络远程传输的内容。

java实现序列化的方式
二进制格式 + 指定语言层级二进制格式 + 跨语言层级JSON 格式化类JSON格式化：XML文件格式化序列化的分类
在速度的对比上一般有如下规律：

• binary > textual
• language-specific > language-unspecific

下面重点介绍下Kryo、fast-serialiation、fastjson、protocol-buffer
Java原生序列化(青铜级别)

• Java本身提供的序列化工具基本上能胜任大多数场景下的序列化任务，关于其序列化机制。
  
• 需要类实现了Serializable或Externalizable接口，否则会抛出异常，然后使用ObjectOutputStream与ObjectInputStream将对象写入写出。
  
• Java自带的序列化工具在序列化过程中需要不仅需要将对象的完整的class name记录下来，还需要把该类的定义也都记录下，包括所有其他引用的类，这会是一笔很大的开销，尤其是仅仅序列化单个对象的时候。
  
• 正因为java序列化机制会把所有meta-data记录下来，因此当修改了类的所在的包名后，反序列化则会报错。

//对象转成字节码 ByteArrayOutputStream byteArrayOutputStream = newByteArrayOutputStream(); 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 和 KryoRegisterKryo的运行速度是java Serializable 的20倍左右
Kryo的文件大小是java Serializable的一半左右
Kryo有两种模式:一种是先注册(regist)，再写对象，即writeObject函数，实际上如果不先注册，在写对象时也会注册，并为class分配一个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; }

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(); } } }

FST序列化机制（钻石级别）

• FST（Fast-serialization-Tool），与kryo类似是apache组织的一个开源项目，完全兼容JDK序列化协议的系列化框架，序列化速度大概是JDK的4-10倍，体积更小，大小是JDK大小1/3左右，重新实现的 Java 快速对象序列化的开发包。
  
• 相对来说是一个很新的序列化工具，速度于kryo有一些差距，在生产环境上的场景上测试，效果几乎于kryo一致，都能瞬间反序列化出内容并渲染。

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); }

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; }

下表是几种方案的各项指标的一个对比
【Java技术专题「性能优化系列」针对Java对象压缩及序列化技术的探索之路】
文章图片

推荐阅读

• 

  八图H5邀请函兴起的原因
• 

  中考志愿怎么填第一批第二批 中考志愿怎么填
• 

  打完新冠疫苗要检查抗体吗
• 

  汽车发动机怠速不稳定是什么原因 发动机怠速不稳定是什么原因有哪些
• 

  笔记本|ROG Zephyrus M16 性能全面升级，兼具台式机级性能
• 

  难忘的父亲节初中作文精选3篇
• 

  酷我音
• 

  广州陶瓷餐具价格怎么样 广州陶瓷餐具哪里有卖
• 

  宜昌一次性吸纳就业补贴对象+电话 宜昌市应届毕业生补贴
• 

  2022世界杯沙特阿拉伯队阵容名单 世界杯沙特阿拉伯队首发阵容
• 

  高三优秀议论文 优秀议论文
• 

  excel如何插入word文档
• 

  志高空调遥控器怎么调制热,注意这些控制技巧
• 

  步步惊心是什么意思 步步惊心的含义
• 

  深圳北站在哪里打的 深圳北站是哪里
• 

  信用卡欠了钱5万实在没钱还会坐牢吗
• 

  真后悔养了博美 养博美犬的好处和坏处
• 

  大学期末考试试卷分析,试卷分析失分原因和改进措施
• 

  住房风水禁忌100例 房屋后面风水禁忌
• 

  美的空调不同产地,每个人都应该了解这些

• 面向对象的封装性
• netty系列之:让TLS支持http2
• 操作符把玩日志
• 更好的 java 重试框架 sisyphus 背后的故事
• 网站Git仓库暴露及不安全文件权限配置可能引发的的安全问题
• C++类和对象--对象特性
• SpringCloud升级之路2020.0.x版-27.OpenFeign的生命周期-创建代理
• 日志技术专题「logback入门到精通」彻彻底底学会logback框架的使用和原理（入门介绍）
• Java多线程