Java 序列化机制详解

Java 序列化机制是一种将对象转换为字节流的过程，以便在网络上传输或保存到文件中，并能在需要时将字节流还原为对象。这一机制通过实现 java.io.Serializable 接口来实现，同时涉及到一些关键概念和注意事项。

java-serial.jpg

Serializable 接口

Serializable 接口是 Java 提供的标记接口，没有包含任何需要实现的方法。实现了这个接口的类表明其对象是可序列化的，可以被转换为字节流。

public interface Serializable {
}

通过实现 Serializable 接口，标识类的对象可以被序列化。这使得对象可以在网络上传输或保存到文件中，而不失去其状态和结构。

序列化过程

序列化是将对象的状态（字段值）转换为字节流的过程。这个过程由 ObjectOutputStream 类来完成。序列化使得对象可以以字节流的形式进行存储或传输，便于在不同系统之间进行数据交换。如下我们列举几个重要的方法的源码：

  • writeObject方法

public final void writeObject(Object obj) throws IOException {if (enableOverride) {writeObjectOverride(obj);return;}try {writeObject0(obj, false);} catch (IOException ex) {if (depth == 0) {writeFatalException(ex);}throw ex;}
}

enableOverride 表示是否启用了对象写入的覆盖机制。如果启用，会调用 writeObjectOverride 方法来执行对象的特定写入逻辑。

如果没有启用覆盖机制，则调用 writeObject0 方法执行实际的对象序列化。

writeObject0 方法负责处理对象的序列化，其中第二个参数 false 表示不使用不共享的方式进行序列化。

如果在序列化过程中抛出 IOException 异常，会捕获该异常。如果当前深度为0（表示不在嵌套序列化过程中），则调用 writeFatalException 方法来处理异常，否则将异常重新抛出。

  • writeObject0

private void writeObject0(Object obj, boolean unshared)throws IOException
{boolean oldMode = bout.setBlockDataMode(false);depth++;try {// handle previously written and non-replaceable objectsint h;if ((obj = subs.lookup(obj)) == null) {writeNull();return;} else if (!unshared && (h = handles.lookup(obj)) != -1) {writeHandle(h);return;} else if (obj instanceof Class) {writeClass((Class) obj, unshared);return;} else if (obj instanceof ObjectStreamClass) {writeClassDesc((ObjectStreamClass) obj, unshared);return;}// check for replacement objectObject orig = obj;Class<?> cl = obj.getClass();ObjectStreamClass desc;for (;;) {// REMIND: skip this check for strings/arrays?Class<?> repCl;desc = ObjectStreamClass.lookup(cl, true);if (!desc.hasWriteReplaceMethod() ||(obj = desc.invokeWriteReplace(obj)) == null ||(repCl = obj.getClass()) == cl){break;}cl = repCl;}if (enableReplace) {Object rep = replaceObject(obj);if (rep != obj && rep != null) {cl = rep.getClass();desc = ObjectStreamClass.lookup(cl, true);}obj = rep;}// if object replaced, run through original checks a second timeif (obj != orig) {subs.assign(orig, obj);if (obj == null) {writeNull();return;} else if (!unshared && (h = handles.lookup(obj)) != -1) {writeHandle(h);return;} else if (obj instanceof Class) {writeClass((Class) obj, unshared);return;} else if (obj instanceof ObjectStreamClass) {writeClassDesc((ObjectStreamClass) obj, unshared);return;}}// remaining casesif (obj instanceof String) {writeString((String) obj, unshared);} else if (cl.isArray()) {writeArray(obj, desc, unshared);} else if (obj instanceof Enum) {writeEnum((Enum<?>) obj, desc, unshared);} else if (obj instanceof Serializable) {writeOrdinaryObject(obj, desc, unshared);} else {if (extendedDebugInfo) {throw new NotSerializableException(cl.getName() + "\n" + debugInfoStack.toString());} else {throw new NotSerializableException(cl.getName());}}} finally {depth--;bout.setBlockDataMode(oldMode);}
}

反序列化过程

当需要从字节流中恢复对象时，Java 序列化机制会将字节流还原为对象的状态。这个过程由 ObjectInputStream 类来完成。如下我们列举几个重要的方法的源码：

  • readObject()

private final Object readObject(Class<?> type)throws IOException, ClassNotFoundException
{if (enableOverride) {return readObjectOverride();}if (! (type == Object.class || type == String.class))throw new AssertionError("internal error");// if nested read, passHandle contains handle of enclosing objectint outerHandle = passHandle;try {Object obj = readObject0(type, false);handles.markDependency(outerHandle, passHandle);ClassNotFoundException ex = handles.lookupException(passHandle);if (ex != null) {throw ex;}if (depth == 0) {vlist.doCallbacks();}return obj;} finally {passHandle = outerHandle;if (closed && depth == 0) {clear();}}
}

这段代码的主要作用是根据给定的类型 (type) 进行对象的反序列化。在这个过程中，它使用了一些状态变量，如 enableOverride、passHandle、handles、depth、vlist 等，来管理反序列化的过程。在处理嵌套对象时，它通过 markDependency 方法标记了当前对象与封闭对象的依赖关系。在深度为 0 时，执行了clear方法。具体反序列化执行的核心方法是readObject0()

  • readObject0()

private Object readObject0(Class<?> type, boolean unshared) throws IOException {boolean oldMode = bin.getBlockDataMode();if (oldMode) {int remain = bin.currentBlockRemaining();if (remain > 0) {throw new OptionalDataException(remain);} else if (defaultDataEnd) {/** Fix for 4360508: stream is currently at the end of a field* value block written via default serialization; since there* is no terminating TC_ENDBLOCKDATA tag, simulate* end-of-custom-data behavior explicitly.*/throw new OptionalDataException(true);}bin.setBlockDataMode(false);}byte tc;while ((tc = bin.peekByte()) == TC_RESET) {bin.readByte();handleReset();}depth++;totalObjectRefs++;try {switch (tc) {case TC_NULL:return readNull();case TC_REFERENCE:// check the type of the existing objectreturn type.cast(readHandle(unshared));case TC_CLASS:if (type == String.class) {throw new ClassCastException("Cannot cast a class to java.lang.String");}return readClass(unshared);case TC_CLASSDESC:case TC_PROXYCLASSDESC:if (type == String.class) {throw new ClassCastException("Cannot cast a class to java.lang.String");}return readClassDesc(unshared);case TC_STRING:case TC_LONGSTRING:return checkResolve(readString(unshared));case TC_ARRAY:if (type == String.class) {throw new ClassCastException("Cannot cast an array to java.lang.String");}return checkResolve(readArray(unshared));case TC_ENUM:if (type == String.class) {throw new ClassCastException("Cannot cast an enum to java.lang.String");}return checkResolve(readEnum(unshared));case TC_OBJECT:if (type == String.class) {throw new ClassCastException("Cannot cast an object to java.lang.String");}return checkResolve(readOrdinaryObject(unshared));case TC_EXCEPTION:if (type == String.class) {throw new ClassCastException("Cannot cast an exception to java.lang.String");}IOException ex = readFatalException();throw new WriteAbortedException("writing aborted", ex);case TC_BLOCKDATA:case TC_BLOCKDATALONG:if (oldMode) {bin.setBlockDataMode(true);bin.peek();             // force header readthrow new OptionalDataException(bin.currentBlockRemaining());} else {throw new StreamCorruptedException("unexpected block data");}case TC_ENDBLOCKDATA:if (oldMode) {throw new OptionalDataException(true);} else {throw new StreamCorruptedException("unexpected end of block data");}default:throw new StreamCorruptedException(String.format("invalid type code: %02X", tc));}} finally {depth--;bin.setBlockDataMode(oldMode);}
}

serialVersionUID

serialVersionUID 是用于版本控制的序列化版本号。它是一个长整型数值，用于标识类的版本。通过显式声明 serialVersionUID，可以在类结构发生变化时依然能够正确地进行反序列化。

@Data
public class LoginUserInfo implements Serializable {private static final long serialVersionUID = 1L;...
}

如果在类中没有明确声明 serialVersionUID，Java 运行时系统会根据类的结构自动生成一个。这种自动生成的 serialVersionUID 是基于类的各个方面的，包括字段、方法、父类等。如果类的结构发生变化，可能导致自动生成的 serialVersionUID 发生变化。这可能会导致在反序列化时，类的版本不一致，从而导致 InvalidClassException 异常。

所以显式声明 serialVersionUID是确保反序列化过程正确的关键，避免因类结构变化而导致的问题。

transient 关键字

关键字 transient 用于标记字段，表示在对象序列化的过程中，这个字段应该被忽略。例如，如果一个类有一个不希望被序列化的缓存字段，可以使用 transient 关键字来避免将其写入序列化数据。例如ArrayList、LinkedList 等类中的一些属性就是使用transient修饰的：

_20231218215928.jpg

_20231218215951.jpg

自定义序列化和反序列化

有时候，可能需要自定义序列化和反序列化的过程以满足特定需求。可以通过实现 writeObject 和 readObject 方法来实现自定义逻辑。如ArrayList类中就是通过自定义的序列化和反序列化方法:

private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException{// Write out element count, and any hidden stuffint expectedModCount = modCount;s.defaultWriteObject();// Write out size as capacity for behavioural compatibility with clone()s.writeInt(size);// Write out all elements in the proper order.for (int i=0; i<size; i++) {s.writeObject(elementData[i]);}if (modCount != expectedModCount) {throw new ConcurrentModificationException();}
}/*** Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,* deserialize it).*/
private void readObject(java.io.ObjectInputStream s)throws java.io.IOException, ClassNotFoundException {elementData = EMPTY_ELEMENTDATA;// Read in size, and any hidden stuffs.defaultReadObject();// Read in capacitys.readInt(); // ignoredif (size > 0) {// be like clone(), allocate array based upon size not capacityint capacity = calculateCapacity(elementData, size);SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);ensureCapacityInternal(size);Object[] a = elementData;// Read in all elements in the proper order.for (int i=0; i<size; i++) {a[i] = s.readObject();}}
}

序列化不保存静态变量

  • 对象状态 vs. 类状态

序列化的主要目的是保存对象的状态，即对象的实例变量。静态变量是类级别的，它们对于每个对象实例都是相同的。序列化关注的是对象的实例状态，因为这是对象在不同环境中重建时所需的关键信息。

  • 节省空间

静态变量通常用于表示类级别的常量或共享数据，这些数据在所有对象实例之间是相同的。如果每个对象的静态变量都被序列化并存储，将导致冗余，浪费存储空间。序列化的目标之一是尽可能紧凑地保存对象的状态，因此不保存静态变量是一种优化。

  • 不需要还原

静态变量在类加载时初始化，并在整个应用程序的生命周期内保持不变。因此，在反序列化时不需要重新初始化静态变量。序列化和反序列化的目标是保存和还原对象的动态状态，而不是类级别的静态状态。

序列化的安全性和性能考虑

在实际应用中，需要注意序列化的安全性和性能。反序列化过程中可能存在安全风险，因此要谨慎处理来自不受信任源的序列化数据。此外，对于大量数据的序列化，可能会影响系统性能，可以考虑使用更高效的序列化工具或压缩算法。

总结

综合来看，Java 序列化的核心思想是将对象的状态转换为字节流，并通过 ObjectOutputStream 类完成这一过程。该类在内部处理了对象引用的记录、对象字段的写入、自定义写入方法的执行等。在实际应用中，我们需要注意序列化版本控制、对象字段的 transient 关键字的处理以及序列化性能等方面的问题。

请注意，Java 序列化机制在现代应用中可能会遇到一些挑战，包括性能问题、安全性问题以及与其他语言的兼容性等。因此，在一些场景下，开发者可能会考虑使用其他序列化框架，如 JSON 或 Protocol Buffers，以满足不同的需求。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/285563.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

企业电子招标采购系统源码Spring Cloud + Spring Boot + 前后端分离 + 二次开发

企业电子招标采购系统源码Spring Cloud + Spring Boot + 前后端分离 + 二次开发

项目说明 随着公司的快速发展&#xff0c;企业人员和经营规模不断壮大&#xff0c;公司对内部招采管理的提升提出了更高的要求。在企业里建立一个公平、公开、公正的采购环境&#xff0c;最大限度控制采购成本至关重要。符合国家电子招投标法律法规及相关规范&#xff0c;以及审…
阅读更多...
“去 Android化”为何蔚然成风？

“去 Android化”为何蔚然成风？

早在2008年时&#xff0c;国内市场诞生了第一批自研手机OS&#xff0c;由于种种缘由铩羽而归&#xff0c;“优化Android ”貌似成为了本土特色。而从2023年下半年开始掀起了一股"去安卓化"的热潮&#xff0c;像华为、小米、vivo等都不约而同的站在了同一战线。 “去…
阅读更多...
制作一个多行时正确宽度的Textview,Android Textview 换行时宽度过长 右侧空白区域挤掉页面元素的解决方案

制作一个多行时正确宽度的Textview,Android Textview 换行时宽度过长 右侧空白区域挤掉页面元素的解决方案

优化 Android 布局&#xff1a;创建自适应宽度的 TextView 引言 在Android应用开发中&#xff0c;布局优化是提升应用性能和用户体验的关键环节之一。特别是对于那些内容密集型的应用&#xff0c;如何高效地展示和管理文本内容成为了一个挑战。最近&#xff0c;在处理一个布局…
阅读更多...
探索关系：Python中的Statsmodels库进阶

探索关系：Python中的Statsmodels库进阶

目录 写在开头1. 多元线性回归场景介绍 2. Logistic回归2.1 Logistic回归的概念2.2 应用案例2.2.1 建立模型和预测2.2.2 模型结论2.2.3 模型优化 3. 时间序列分析3.1 时间序列分析中的应用3.2 利用Statsmodels进行简单的时间序列分析 写在最后 写在开头 在数据分析的旅程中&am…
阅读更多...
基于Arduino的智能太阳能追光系统（论文+源码）

基于Arduino的智能太阳能追光系统（论文+源码）

1. 系统设计 本次的设基于Arduino的智能太阳能追光系统的设计&#xff0c;整体结构如图2.1所示。整个系统包括Arduino开发板&#xff0c;按键模块&#xff0c;太阳能板&#xff0c;X轴电机,Y轴电机&#xff0c;电池充电模块&#xff0c;电源模块&#xff0c;四路光照检测模块等…
阅读更多...
Redis10大性能优化策略

Redis10大性能优化策略

1.Redis为什么变慢了 1.Redis真的变慢了吗&#xff1f; 对 Redis 进行基准性能测试 例如&#xff0c;我的机器配置比较低&#xff0c;当延迟为 2ms 时&#xff0c;我就认为 Redis 变慢了&#xff0c;但是如果你的硬件配置比较高&#xff0c;那么在你的运行环境下&#xff0c;可…
阅读更多...
宋仕强论道之华强北的机会（二十五）

宋仕强论道之华强北的机会（二十五）

华强北还有机会吗&#xff1f;我宋仕强认为华强北机会是有的&#xff0c;现在有点困难的兄弟们一定要撑住了。我们来来看看宏观数据&#xff0c;电子元器总市场份额全世界接近6,000亿美金&#xff0c;带动产业链上下游的产值约为15-20倍&#xff0c;市场非常大。本产业最少还会…
阅读更多...
electron与cesium组件入门应用功能

electron与cesium组件入门应用功能

electron与cesium组件入门应用功能 运行应用效果图&#xff1a; electron应用目录&#xff0c;需要包括三个文件: index.html main.js package.json (一)、创建一个新项目 目录名称&#xff1a;project_helloWolrd (二)、生成package.json文件 npm init --yes(三&#x…
阅读更多...
用Python编辑PDF文件：拆分合并、加密解密、页面编辑

用Python编辑PDF文件：拆分合并、加密解密、页面编辑

文章目录 安装和初步使用合并与拆分页面编辑加密解密 安装和初步使用 PyPDF2支持拆分、合并、页面旋转、添加水印、加密解密等操作。支持pip安装&#xff0c;过程很丝滑。 pip install PyPDF2PyPDF2提供了PdfFileReader类&#xff0c;可用于读取PDF文件&#xff0c;其metadat…
阅读更多...
html之CSS的高级选择器应用

html之CSS的高级选择器应用

文章目录 一、CSS高级选择器有哪些呢&#xff1f;二、高级选择器的应用1、层次选择器后代选择器子选择器相邻兄弟选择器通用兄弟选择器 2、结构伪类选择器&#xff08;不常用&#xff09;3、属性选择器E[attr]E[attrval]E[attr^val]E[attr$val]E[attr*val] 一、CSS高级选择器有…
阅读更多...
充电桩测试系统的核心组成

充电桩测试系统的核心组成

充电桩测试系统是电动汽车充电设施的重要组成部分&#xff0c;它的主要功能是对充电桩的性能、安全性和可靠性进行全面的检测和评估。电源模块是充电桩测试系统的基础&#xff0c;负责为整个测试系统提供稳定的工作电压和电流。电源模块通常包括交流电源、直流电源和电池模拟器…
阅读更多...
Java期末复习基础知识（for PTA）

Java期末复习基础知识（for PTA）

一.判断题 1.Object是Java中所有类的共同父类。T Object是Java中所有类的共同父类。在Java中&#xff0c;每个类都直接或间接继承自Object类。因此&#xff0c;Object类中的方法&#xff08;如equals()、hashCode()、toString()等&#xff09;都可以在任意Java对象上调用 2.Jav…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023