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

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

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后的话

无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。
同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，好了希望这篇文章对大家有帮助！

部分截图：

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
d36.jpg" alt=“img” style=“zoom: 33%;” />

最后的话

无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。
同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，好了希望这篇文章对大家有帮助！

部分截图：
[外链图片转存中…(img-blSPVbqD-1712318121270)]

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！