Java 序列化机制详解

news2024/11/25 20:27:21

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 objects
        int 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 object
        Object 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 time
        if (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 cases
        if (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 object
    int 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 object
                return 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 read
                    throw 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 stuff
    int 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 stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        // be like clone(), allocate array based upon size not capacity
        int 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.coloradmin.cn/o/1321141.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

vscode使用remote ssh到server上 - Node进程吃满CPU

起因&#xff1a;Node进程吃满CPU 分析 我发现每次使用vscode的remote插件登陆到server后&#xff0c;就会出现node进程&#xff0c;不太清楚干什么用的&#xff0c;但是绝对和它有关。 查找原因 首先找到了这篇文章&#xff0c;解决了rg进程的问题&#xff1a; https://blo…

Shell编程基础 – C语言风格的Bash for循环

Shell编程基础 – C语言风格的Bash for循环 Shell Programming Essentials - C Style For Loop in Bash By JacksonML 循环是编程语言的基本概念之一&#xff0c;同样也是Bash编程的核心。当用户需要一遍又一遍地运行一系列命令直到达到特定条件时&#xff0c;例如&#xff1…

知识蒸馏:channel wise知识蒸馏CWD

论文:https://arxiv.org/pdf/2011.13256.pdf 1. 摘要 知识蒸馏用于训练紧凑型(轻量)模型被证明是一种简单、高效的方法, 轻量的学生网络通过教师网络的知识迁移来实现监督学习。大部分的KD方法都是通过algin学生网络和教师网络的归一化的feature map, 最小化feature map上的…

数据结构--图

树具有灵活性&#xff0c;并且存在许多不同的树的应用&#xff0c;但是就树本身而言有一定的局限性&#xff0c;树只能表示层次关系&#xff0c;比如父子关系。而其他的比如兄弟关系只能够间接表示。 推广--- 图 图形结构中&#xff0c;数据元素之间的关系是任意的。 一、图…

内网安全—Windows系统内核溢出漏洞提权

系统内核溢出漏洞提权 往缓冲区中写入超出限定长度的内容&#xff0c;造成缓冲区溢出&#xff0c;从而破坏程序的堆栈进而运行自己精心准备的指定代码&#xff0c;达到攻击的目的。 分类&#xff1a; 堆溢出 栈溢出 查找补丁的方法 1、手工查找补丁情况 systeminfo Wmic qfe…

Redis设计与实现之Lua 脚本

目录 一、 Lua 脚本 1、初始化 Lua 环境 2、脚本的安全性 3、脚本的执行 4、 EVAL 命令的实现 定义 Lua 函数 执行 Lua 函数 5、 EVALSHA 命令的实现 二、 小结 一、 Lua 脚本 Lua 脚本功能是 Reids 2.6 版本的最大亮点&#xff0c;通过内嵌对 Lua 环境的支持&#xf…

加特兰Demo点迹数据Python读取和显示

加特兰当前主推的芯片&#xff0c;拿到了样件做了几个基本Demo测试&#xff0c;录取的点迹数据为txt文档&#xff0c;数据格式如下&#xff1a; FT 0.10 CMN1 263 CMN2 150 BNK 0 --- F 0 O 140/2/140!0/0/0/0/0/0.00! --- BK00: P 25.67, R 4.11, V 0.00, A -39.04,…

AR室内导航如何实现?技术与原理分析

随着科技的进步&#xff0c;我们生活中许多方面正在被重新定义。其中之一就是导航&#xff0c;尤其是室内导航。增强现实&#xff08;AR&#xff09;技术的出现为室内导航带来了革命性的变革。本文将深入探讨AR室内导航的技术与原理&#xff0c;以及它如何改变我们的生活方式。…

bat批处理:git上传更新

查看专栏目录 Network 灰鸽宝典专栏主要关注服务器的配置&#xff0c;前后端开发环境的配置&#xff0c;编辑器的配置&#xff0c;网络服务的配置&#xff0c;网络命令的应用与配置&#xff0c;windows常见问题的解决等。 文章目录 批处理背景批处理代码代码说明&#xff1a;使…

Hadoop Single Node Cluster的安装

Hadoop Single Node Cluster的安装 安装JDK查看java -version更新本地软件包安装JDK查看java安装位置 设置SSH无密码登录安装hadoop下载安装设置hadoop环境变量修改hadoop配置设置文件设置core-site.xml设置YARN-site.xml设置mapred-site.xml设置HDFS分布式文件系统创建并格式化…

[ CTF ]【天格】战队WriteUp-第七届“强网杯”全国安全挑战赛

第七届“强网杯”全国安全挑战赛 2023.12.16~2023.12.17 文章目录 【Misc】Pyjail ! Its myFILTER !!!easyfuzz谍影重重2.0签到Pyjail ! Its myRevenge !!!server_8F6C72124774022B.py 问卷调查 【Reverse】ezre 【Web】happygame 【强网先锋】石头剪刀布TrieSpeedUpezreez_fmt…

翻译: LLMs新的工作流程和新的机会 New workflows and new opportunities

生成人工智能正以多种方式引领着不仅仅是成本节约&#xff0c;更是收入增长。但是&#xff0c;就像生成人工智能这样的通用技术创造价值的方式有很多&#xff0c;谈论这些方式是很多的。但在这个视频中&#xff0c;我想看看一些我看到的新兴的&#xff0c;或者更常见的走向这种…

Java 8 中的 Stream:优雅的集合处理

Java 8 中的 Stream&#xff1a;优雅的集合处理 为什么需要 Stream&#xff1f;Stream 的特性Stream 基本操作1. 创建 Stream2. 中间操作2.1 过滤&#xff08;Filter&#xff09;2.2 映射&#xff08;Map&#xff09;2.3 截断&#xff08;Limit&#xff09; 3. 终端操作3.1 遍历…

STM32内部是怎么工作的

STM32是怎么工作的 1 从孩子他妈说起2 早期计算机的组成2.1 五大元件&#xff08;1&#xff09;第一个出场的是电容元件&#xff08;2&#xff09;第二个出场的是二极管&#xff08;3&#xff09;第三个出场的是电阻元件&#xff08;4&#xff09;第四个出场的是电感&#xff0…

其他配置相关安装

consul安装和配置 docker run -d -p 8500:8500 -p 8300:8300 -p 8301:8301 -p 8302:8302 -p 8600:8600/udp consul consul agent -dev -client0.0.0.0访问&#xff1a;http://192.168.0.102:8500/ DNS查询 dig 192.168.0.102 -p 8600 consul.service.consul SRVnacos安装 ht…

华为OS与麒麟OS:华为自研操作系统的对决

导言 在移动操作系统领域&#xff0c;华为OS和麒麟OS代表了华为在自主研发方面的努力。本文将深入探讨这两个操作系统的特点、竞争关系以及它们在用户体验、生态系统建设等方面的差异。 1. 背景与起源 华为OS的诞生&#xff1a; 华为OS是华为公司为应对外部环境而自主…

12.18_黑马数据结构与算法笔记Java

目录 thinking:orElse? thinking:map.computerifabsent? thinking&#xff1a;subString&#xff1f; 184 哈希表 问2 解释拆分 185 哈希算法 概述 186 哈希算法 Object.hashCode 187 哈希算法 String.hashCode 188 哈希算法 冲突测试 189 哈希算法 MurmurHash 190…

Linux操作系统:自由、稳定、强大的开源之光

导言 Linux操作系统作为一个开源的、多用户、多任务、支持多线程和多CPU的UNIX类操作系统&#xff0c;不仅在服务器领域占有显著份额&#xff0c;也逐渐在桌面和嵌入式系统中崭露头角。Linux操作系统的多样性体现在各种不同的发行版上&#xff0c;而Ubuntu、CentOS和Red Hat可以…

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

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

用户行为分析遇到的问题-ubantu16,hadoop3.1.3

用户行为分析传送门 我的版本 ubantu16 hadoop 3.1.3 habse 2.2.2 hive3.1.3 zookeeper3.8.3 sqoop 1.46/1.47 我sqoop把MySQL数据往hbase导数据时候有问题 重磅&#xff1a;大数据课程实验案例&#xff1a;网站用户行为分析&#xff08;免费共享&#xff09; 用户行为分析-小…