java 对象互相引用 序列化 导致栈溢出例子

最新推荐文章于 2024-05-05 07:15:00 发布
原创 最新推荐文章于 2024-05-05 07:15:00 发布 · 1.1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文通过一个实例展示了在Java中，当两个实现了Serializable接口的对象互相引用时，进行序列化会导致栈溢出错误。这个问题是由于Jackson在序列化过程中陷入了无限递归。解决方法是在相互引用的属性上使用@JsonIgnore注解，避免在序列化时处理该字段，从而消除循环引用引发的错误。

在Java对象中如果A,B都实现了Serializable接口 并且互相引用 在进行序列化的时候 会出现循环引用导致栈溢出的问题

例子

新建类A

public class A implements Serializable {
    private int a;
    private String b;
    private B bb;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public String getB() {
        return b;
    }

    public void setB(String b) {
        this.b = b;
    }

    public B getBb() {
        return bb;
    }

    public void setBb(B bb) {
        this.bb = bb;
    }

}

新建类B

public class B implements Serializable {
    private int c;
    private String d;

    private A a;
    public int getC() {
        return c;
    }

    public void setC(int c) {
        this.c = c;
    }

    public String getD() {
        return d;
    }

    public void setD(String d) {
        this.d = d;
    }

    public A getA() {
        return a;
    }

    public void setA(A a) {
        this.a = a;
    }
}

A和B互相引用 此处用的jackson进行序列化
新建SerializableTest

public class SerializableTest {
    public static void main(String[] args) throws Exception{
        A a = new A();
        B b = new B();

        a.setA(1);
        a.setB("b");
        a.setBb(b);


        b.setC(2);
        b.setD("d");
        b.setA(a);

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        oos.writeObject(a);

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
        A aa = (A)ois.readObject();;

        ObjectMapper objectMapper = new ObjectMapper();
        String s = objectMapper.writeValueAsString(aa);
        System.out.println(s);

    }
}

运行结果

	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:727)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
Caused by: java.lang.StackOverflowError
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
	at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
	at java.net.URLClassLoader.defineClass(URLClassLoader.java:467)
	at java.net.URLClassLoader.access$100(URLClassLoader.java:73)
	at java.net.URLClassLoader$1.run(URLClassLoader.java:368)
	at java.net.URLClassLoader$1.run(URLClassLoader.java:362)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.net.URLClassLoader.findClass(URLClassLoader.java:361)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:740)
	... 1011 more
*** java.lang.instrument ASSERTION FAILED ***: "!errorOutstanding" with message transform method call failed at JPLISAgent.c line: 844
*** java.lang.instrument ASSERTION FAILED ***: "!errorOutstanding" with message transform method call failed at JPLISAgent.c line: 844
*** java.lang.instrument ASSERTION FAILED ***: "!errorOutstanding" with message transform method call failed at JPLISAgent.c line: 844
*** java.lang.instrument ASSERTION FAILED ***: "!errorOutstanding" with message transform method call failed at JPLISAgent.c line: 844
*** java.lang.instrument ASSERTION FAILED ***: "!errorOutstanding" with message transform method call failed at JPLISAgent.c line: 844
*** java.lang.instrument ASSERTION FAILED ***: "!errorOutstanding" with message transform method call failed at JPLISAgent.c line: 844

在实际项目开发 可以采用
@JsonIgnore注解 在成员属性上加上即可忽略序列化 从而不会出现这样的问题

jackson的Infinite recursion (StackOverflowError)
lucyLee的博客
03-09 4988
解决Jackson循环引用的问题
JAVA Json 序列化异常？循环引用与 Lazy Loading 导致的栈溢出问题
最新发布
weixin_41455464的博客
11-05 271
首先，我们快速回顾一下 JSON 序列化的概念。JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。在 Java 中，JSON 序列化指的是将 Java 对象转换为 JSON 字符串的过程。例如，我们有一个简单的 Java 类Personreturn age;使用 Gson 库，我们可以将Person// 输出: {"name":"Alice","age":30}
java fx 报错 java.lang.instrument ASSERTION FAILED ***: “!errorOutstanding“ with message transform
热门推荐
xc979906570的博客
07-30 1万+
在javafx中遇到的错误在fxml中通过了fxcontroller绑定了控制器在控制的controller里面使用了FXMLLoader.load获取这个fxml文件出现报错。
JAVA——》模拟虚拟机栈溢出
小仙~
09-07 2400
JAVA——》模拟虚拟机栈溢出
java内存泄露的原因面试_面试官：小伙子，你给我说一下Java中什么情况会导致内存泄漏呢？...
weixin_42315341的博客
02-23 284
概念内存泄露：指程序中动态分配内存给一些临时对象，但对象不会被GC回收，它始终占用内存，被分配的对象可达但已无用。即无用对象持续占有内存或无用对象的内存得不到及时释放，从而造成的内存空间浪费。可达性分析算法JVM使用可达性分析算法判断对象是否存活。GC Root通过一系列名为“GC Roots”的对象作为起点，从这些结点开始向下搜索，搜索所走过的路径称为“引用链(Reference Chain)”...
java中的Serializable接口
键者天行
10-09 8270
    序列化是把一个对象的状态写入一个字节流的过程，它执行RMI，RMI允许一台机器上的JAVA对象调用不同机器上的JAVA对象方法，对象可以作为参数提供给那个远程方法，发送机序列化该对象并传送它，接收机执行反序列化。 序列化和反序列化的关系图表可形成包含循环引用的顺序图表。这是整个序列化的总体思想。 而Serializable接口属于支持序列化的一个接口，只有一个实现它的对象可以被序列化工具存
Java反序列化json内存溢出_fastJson与一起堆内存溢出'血案'
weixin_29465407的博客
03-08 1728
现象QA同学反映登录不上服务器排查问题1–日志级别查看log,发现玩家登录的时候抛出了一个java.lang.OutOfMemoryError大概代码是向Redis序列化一个PlayerMirror镜像数据,但是在JSON.toJSONString的时候出现了错误.比较清晰，即序列化的时候expandCapacity,内存不足。又看了一下日志，有好几个OutOfMemoryError,都是类似于用...
Java IO篇：序列化与反序列化
青藤的博客
07-14 913
这意味着，在反序列化字节流的过程中，该方法可以执行任意类型的代码，Java序列化只支持Java语言实现的框架，其它语言大部分都没有使用Java的序列化框架，也没有实现Java序列化这套协议，因此，两个不同语言编写的应用程序之间通信，无法使用Java序列化实现应用服务间传输对象的序列化和反序列化。Hessian2.0中序列化二进制流大小是Java序列化的50%，序列化耗时是Java序列化的30%，反序列化耗时是Java反序列化的20%。...
一文掌握：Java中防止对象溢出与不安全发布
逆流的小鱼
05-05 1377
安全发布确保对象在发布到其他线程时，状态的正确性和可见性得到保障。换言之，当一个对象被安全发布时，任何线程都能看到这个对象的最新状态且不会遇到过期数据的问题。安全发布的方法包括但不限于使用final关键字、volatile关键字、锁（synchronized block）或者原子引用。
SerializationUtils：Java对象序列化与反序列化的终极武器（专家级教程）
Java对象序列化与反序列化基础 在Java编程中，对象序列化是一个核心概念，它指的是将对象状态信息转换为可以存储或传输的形式的过程。反序列化则是序列化的逆过程，即将这些存储或传输的形式还原为Java对象。这在...
java 序列化 内存溢出_JAVA内存溢出异常解决方案
weixin_33480380的博客
02-16 530
一 调整 虚拟机参数二 立即 释放无用的对象三 利用序列化和反序列化技术下面是具体的代码实现package com.free;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IO...
jackson序列化dubbo URL栈溢出问题
阿呆的专栏
12-28 1185
jackson版本：2.8.1 问题描述 测试环境打开dubbo的result log日志出现如下异常 2019-12-24 11:16:03,753 ERROR [DubboMonitorSendTimer-thread-2] com.....dubbo.utils.ResultLogger:log:34 记录日志异常 com.fasterxml.jackson.databind.JsonMap...
gson序列化抛出StackOverflowError异常
浅醉樱花雨的专栏
10-16 5646
问题描述 使用gson库将实体对象序列化为json字符串时，出现StackOverflowError异常。如图： 经过排查，发现问题出在循环依赖上。简化版示例代码如下 public class A { private String name; private B b; public A(String name) { this.b = new B(this); this.name ...
类循环依赖引起的栈溢出
硅脂味咖啡的博客
09-01 1015
测试代码： import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import java.util.Arrays; import java.util.List; /** * 类循环依赖引起的栈溢出 */ public class ClassCycleTest { /** * 员工类，这里有部门类集合 */
java两个引用引用同一个对象,如果两个对象引用指向同一个可序列化的对象，那么在java中序列化期间会发生什么？...
weixin_35755188的博客
02-28 263
What happens during serialization in java, if two object refrences are pointing to the same serializable Object? Does the Serializable Objects get saved twice ?for example :class King implements java....
[js] 举例说明Object.defineProperty会在什么情况下造成循环引用导致栈溢出？
歌谣的博客
01-04 940
[js] 举例说明Object.defineProperty会在什么情况下造成循环引用导致栈溢出？ var data = { count: 1, value: 2 } Object.defineProperty(data, 'count', { enumerable: true, configurable: true, get: function () { console.log('你访问了count', this.count); // 循环读取da
GSON 循环引用的对象转为 JSON 造成栈溢出
weixin_30493401的博客
07-10 2514
对象转 JSON 可能引发栈溢出的异常，一般是因为对象中的循环引用引起不断递归。 常见的作法就是： 换一种 JSON 的序列化工具，比如fastjson 默认支持消除对同一对象循环引用 transient 修饰属性 显式排除对象的某些属性 1. java对象引用成环说明 1.1 相互引用成环： class A{ B b; } class B...
java 中的Serializable
sdlcgxcqx的专栏
07-30 499
转序列化是把一个对象的状态写入一个字节流的过程，它执行RMI，RMI允许一台机器上的JAVA对象调用不同机器上的JAVA对象方法，对象可以作为参数提供给那个远程方法，发送机序列化该对象并传送它，接收机执行反序列化。序列化和反序列化的关系图表可形成包含循环引用的顺序图表。这是整个序列化的总体思想。而Serializable接口属于支持序列化的一个接口，只有一个实现它的对象可以被序
对象循环引用与序列化问题
走进技术的世界
02-22 6786
几种序列化方案对循环引用的对象的处理及一般规律
Java集合的反序列化
07-26
<think>我们正在处理Java集合的反序列化问题。根据用户提供的引用，我们可以总结出以下几点关键信息： 1. 引用[1]展示了一个自定义反序列化的例子，通过`readObject`方法手动读取数据并重建集合对象。 2. 引用[2]提到了将集合序列化为JSON字符串的工具方法，但用户的问题是关于反序列化，所以我们可能需要关注如何从JSON反序列化回集合。 3. 引用[3]则展示了在序列化和反序列化过程中自定义处理数据的例子，并提出了一个常见问题：哪些对象可以被序列化？ 用户的问题集中在Java集合的反序列化方法及常见问题上。因此，我们将围绕如何正确反序列化Java集合以及可能遇到的问题展开回答。 ### Java集合的反序列化 在Java中，集合的反序列化通常指将序列化后的字节流（或JSON等格式的字符串）转换回集合对象的过程。根据序列化方式的不同，反序列化方法也有所区别。这里我们主要讨论两种常见情况：Java原生序列化和JSON序列化。 #### 1. Java原生序列化 Java原生序列化使用`ObjectOutputStream`和`ObjectInputStream`。要使一个类的对象可序列化，该类必须实现`java.io.Serializable`接口。集合类（如`ArrayList`, `HashSet`等）已经实现了该接口，因此可以直接序列化和反序列化。 **基本反序列化方法：** ```java try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("data.ser"))) { List<String> list = (List<String>) ois.readObject(); } ``` **自定义反序列化：** 有时我们需要在反序列化过程中进行一些自定义操作（如解密、数据校验等）。这时可以在集合所在的类中定义`readObject`方法。例如，引用[1]中展示了如何自定义反序列化一个包含字符串列表的类： ```java private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { int size = ois.readInt(); names = new ArrayList<>(size); for (int i = 0; i < size; i++) { names.add((String) ois.readObject()); } } ``` #### 2. JSON序列化与反序列化 在实际应用中，JSON格式更为常见。我们可以使用如Jackson、Gson等库来实现集合与JSON字符串之间的转换。 以Jackson库为例，反序列化一个集合的步骤如下： 1. 创建`ObjectMapper`实例。 2. 使用`readValue`方法将JSON字符串转换为集合对象。由于Java泛型的类型擦除，我们需要使用`TypeReference`来指定集合的具体类型。 **示例：** ```java ObjectMapper objectMapper = new ObjectMapper(); String json = "[ \"apple\", \"banana\", \"cherry\" ]"; List<String> list = objectMapper.readValue(json, new TypeReference<List<String>>() {}); ``` ### 常见问题及解决方法 1. **哪些对象可以被序列化？** - 只有实现了`Serializable`接口的类的对象才能被Java原生序列化。集合类（如`ArrayList`, `HashMap`等）都实现了该接口。但是，如果集合中的元素没有实现`Serializable`，则序列化时会抛出`NotSerializableException`[^3]。 2. **序列化版本不一致问题（`InvalidClassException`）** - 如果序列化后修改了类的结构（如增加了字段），反序列化时可能会因序列版本UID（`serialVersionUID`）不匹配而失败。解决方法是在类中显式声明一个固定的`serialVersionUID`： ```java private static final long serialVersionUID = 1L; ``` 3. **反序列化安全风险** - 反序列化不受信任的数据可能导致安全问题，如远程代码执行（RCE）。避免反序列化来自不可信源的数据。如果必须这样做，可以考虑使用白名单验证对象类型，或者使用JSON等更安全的序列化格式。 4. **集合元素为自定义对象** - 当集合中的元素是自定义类时，该类也必须实现`Serializable`接口（对于Java原生序列化）。对于JSON反序列化，自定义类不需要实现`Serializable`，但需要有默认构造器（或能通过其他方式构造），并且字段需要与JSON属性匹配（或通过注解配置）。 5. **性能问题** - 对于大型集合，反序列化可能消耗较多内存和时间。使用JSON时，可以尝试流式解析（如Jackson的`JsonParser`）来减少内存占用。 6. **循环引用问题** - 当集合中的对象存在循环引用时，使用某些序列化库（如Jackson默认配置）可能会导致栈溢出。可以通过配置忽略循环引用（如`@JsonIgnoreProperties`）或使用`@JsonManagedReference`和`@JsonBackReference`解决。 ### 总结 Java集合的反序列化可以通过Java原生序列化或JSON序列化库实现。在反序列化过程中，需要注意对象的可序列化性、版本兼容性、安全性以及性能等问题。根据具体需求选择合适的序列化方式，并采取相应的安全措施和性能优化手段。 §§相关问题§§ 1. 如何解决Java反序列化中的版本不一致问题？ 2. 使用JSON反序列化集合时，如何处理泛型类型？ 3. 如何避免Java反序列化安全漏洞？ 4. 在反序列化大型集合时，如何优化内存使用？</think>### Java集合反序列化方法及常见问题 Java集合的反序列化是将序列化的字节流恢复为内存中的集合对象的过程。根据引用内容，以下是核心方法和常见问题： #### 一、反序列化方法 1. **Java原生反序列化** ```java try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("data.ser"))) { List<String> list = (List<String>) ois.readObject(); // 强制类型转换 } ``` - 要求集合元素必须实现`Serializable`接口 - 使用`readObject()`方法读取对象[^3] 2. **自定义反序列化（覆盖readObject）** ```java private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { int size = ois.readInt(); // 读取集合大小 names = new ArrayList<>(size); for (int i = 0; i < size; i++) { names.add((String) ois.readObject()); // 逐个读取元素 } } ``` - 适用于需要特殊处理（如解密、校验）的场景[^1] 3. **JSON反序列化（使用Jackson库）** ```java ObjectMapper mapper = new ObjectMapper(); List<User> users = mapper.readValue(jsonString, new TypeReference<List<User>>(){}); ``` - 需处理`JsonProcessingException`[^2] - 要求集合元素有无参构造器 #### 二、常见问题及解决方案 1. **类型转换异常（ClassCastException）** - **原因**：序列化与反序列化的类版本不一致 - **解决**： ```java private static final long serialVersionUID = 1L; // 显式声明版本ID ``` 2. **元素不可序列化（NotSerializableException）** - **原因**：集合元素未实现`Serializable` - **示例**：`List<NonSerializableObj>`会抛出异常 - **解决**：确保所有元素实现`Serializable`[^3] 3. **安全漏洞（反序列化攻击）** - **风险**：恶意字节流可执行任意代码 - **防护**： ```java ois.setObjectInputFilter( // JDK 9+ filterInfo -> Class.class.equals(filterInfo.serialClass()) ? ObjectInputFilter.Status.REJECTED : ObjectInputFilter.Status.UNDECIDED ); ``` 4. **JSON反序列化泛型擦除** - **问题**：`List<User>`运行时变为`List<Object>` - **解决**：使用`TypeReference`保留泛型信息[^2] ```java mapper.readValue(json, new TypeReference<List<User>>(){}); ``` 5. **循环引用问题** - **现象**：对象间相互引用导致栈溢出 - **解决**：JSON中使用`@JsonIgnoreProperties(ignoreUnknown=true)` #### 三、最佳实践 1. **敏感字段处理**： ```java private transient String password; // 不被序列化 ``` 2. **大型集合优化**： - 分块序列化（如每10,000元素存一个文件） - 使用`ArrayList`而非`LinkedList`（内存连续） 3. **版本兼容**： - 修改类结构后需保持`serialVersionUID`一致 4. **数据校验**： ```java private void readObject(ObjectInputStream ois) ... { // 反序列化后执行校验 if(size < 0) throw new InvalidObjectException("非法大小"); } ``` > **关键点**：集合反序列化本质是递归重建对象树的过程，需确保对象图的完整性和一致性[^1][^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值