Java高级程序员需要掌握的序列化和反序列化知识点包括以下几个方面：
-
Serializable接口：
- 理解Serializable接口的作用和原理。
- 熟悉Serializable接口的使用方法，将需要序列化的类实现Serializable接口。
-
transient关键字：
- 了解transient关键字的作用，即标记字段为瞬态的，不参与序列化过程。
- 理解在何种情况下应该使用transient关键字来排除某些字段的序列化。
-
版本控制：
- 了解序列化版本控制的概念和机制。
- 学习如何通过serialVersionUID来控制序列化版本，确保反序列化时版本的兼容性。
-
Externalizable接口：
- 了解Externalizable接口和Serializable接口的区别。
- 学习如何通过实现Externalizable接口来自定义序列化和反序列化过程。
-
对象图的序列化：
- 理解对象图的概念，即被序列化对象的整个引用网络。
- 学习如何处理对象图中的循环引用和共享对象，以避免序列化过程中的问题。
-
性能优化：
- 了解序列化和反序列化的性能影响因素。
- 学习性能优化的技巧，如使用序列化代理、自定义序列化形式等，提高序列化和反序列化的效率。
-
安全性：
- 理解序列化和反序列化的安全风险，如对象篡改、远程代码执行等。
- 学习如何防范序列化和反序列化的安全漏洞，如使用安全的序列化库、实施对象签名验证等。
-
其他技术：
- 熟悉与序列化和反序列化相关的其他技术，如JSON序列化、XML序列化等。
- 学习如何在不同场景下选择合适的序列化方式，以满足需求和性能要求。
Serializable接口
Serializable接口是Java提供的一种标记接口（marker interface），它没有任何方法，仅仅是用来标识类的实例可以被序列化（serialization）。
作用：
- 序列化支持：Serializable接口的存在告诉Java虚拟机，该类的对象可以被序列化成字节序列。
- JVM支持：JVM在进行序列化操作时，会检查被序列化的类是否实现了Serializable接口，如果没有实现，则会抛出NotSerializableException。
原理：
Java中的序列化是将对象的状态信息转换为字节流的过程，以便将其存储在内存、磁盘或通过网络传输。当一个类实现了Serializable接口时，Java序列化机制就会对该类进行特殊处理，具体原理包括：
-
标记接口：Serializable接口不包含任何方法，只是作为一个标记，告诉编译器该类是可序列化的。
-
对象状态转换：在序列化过程中，Java虚拟机会逐个遍历对象的所有属性，并将它们转换为字节流。
-
对象结构保持：序列化过程会保持对象的结构，即对象的层次结构、字段的类型和相互关系等都会得到保留。
-
写入对象流：将序列化后的字节流写入到输出流（如文件输出流、网络输出流）中，以便存储或传输。
-
反序列化还原：当需要恢复对象时，通过反序列化，将字节流重新转换为对象的状态信息，恢复对象的状态。
序列化反序列化常见坑
序列化和反序列化过程中存在一些潜在的坑，需要开发人员注意避免，以确保数据的正确性和系统的稳定性。以下是一些常见的序列化和反序列化的坑：
-
版本兼容性问题：
- 序列化对象的类结构发生变化时，可能导致反序列化失败。为了解决这个问题，可以通过指定serialVersionUID或使用Externalizable接口来控制版本兼容性。
-
安全漏洞：
- 反序列化攻击（Deserialization Vulnerabilities）是常见的安全漏洞之一。恶意攻击者可以构造恶意序列化数据，触发远程代码执行等危险操作。开发人员需要谨慎处理反序列化数据，避免安全风险。
-
transient字段处理：
- 使用transient关键字标记的字段在序列化过程中会被忽略，这意味着这些字段在反序列化后会被恢复为默认值。开发人员需要确保在反序列化后手动恢复这些字段的状态，以避免意外行为。
-
循环引用和共享对象：
- 当序列化对象图中存在循环引用或共享对象时，可能导致序列化和反序列化过程中的问题，如栈溢出、无限循环等。开发人员需要特别注意处理这种情况，可以通过使用transient关键字或自定义序列化和反序列化逻辑来避免问题的发生。
-
性能问题：
- 序列化和反序列化过程可能会消耗大量的系统资源，尤其是对于大对象或复杂对象图。开发人员需要优化序列化和反序列化的性能，可以通过选择合适的序列化库、压缩数据、避免冗余字段等方式来提高性能。
-
外部资源处理：
- 如果序列化对象中包含外部资源（如文件句柄、数据库连接等），在反序列化后需要正确地重新初始化这些资源，以确保系统的稳定性和正确性。
反序列化攻击原理
反序列化攻击（Deserialization Attack）是利用序列化机制中的漏洞进行恶意操作的攻击方式。攻击者通过构造恶意的序列化数据，在反序列化过程中执行任意代码或进行不当操作，导致系统受到攻击。以下是对反序列化攻击的详细介绍：
反序列化攻击的原理
-
序列化和反序列化机制：
- 序列化是将对象的状态转换为字节流的过程，反序列化是将字节流还原为对象的过程。
- 在反序列化过程中，Java会根据字节流中的信息，调用相关类的构造方法和其他方法来恢复对象。
-
攻击原理：
- 攻击者可以构造恶意的字节流，包含特定类的构造信息和方法调用。
- 当系统反序列化这个恶意字节流时，会执行这些类的构造方法和其他方法，从而执行恶意代码。
反序列化攻击的影响
-
任意代码执行：
- 通过反序列化，攻击者可以执行任意代码，可能导致远程代码执行漏洞。
-
拒绝服务：
- 通过构造恶意的序列化数据，攻击者可以使系统进入异常状态，导致服务不可用。
-
数据泄露：
- 反序列化恶意数据可能导致敏感信息的泄露。
-
系统完整性破坏：
- 攻击者可以利用反序列化漏洞修改系统数据，破坏系统完整性。
反序列化攻击示例
以下是一个简单的反序列化攻击示例：
假设我们有一个易受攻击的类：
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
public class VulnerableClass implements Serializable {
private static final long serialVersionUID = 1L;
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ois.defaultReadObject();
Runtime.getRuntime().exec("calc.exe"); // 恶意代码
}
}
在反序列化过程中，readObject 方法被调用，并执行了恶意代码（在这个例子中，打开计算器）。
防御反序列化攻击的最佳实践
-
避免反序列化不受信任的数据：
- 不要对不受信任的来源数据进行反序列化操作。
-
使用白名单：
- 使用白名单机制，仅允许反序列化特定的类。可以通过
ObjectInputStream的resolveClass方法来实现。
- 使用白名单机制，仅允许反序列化特定的类。可以通过
-
对象替换：
- 使用
readObject方法中的ObjectInputStream.readObject()方法，对象替换机制来过滤和验证反序列化对象。
- 使用
-
使用安全的库：
- 使用一些安全的序列化库，这些库通过内置机制防止反序列化漏洞。例如：Kryo、XStream 等。
-
限制性别名映射：
- 在使用某些序列化框架（如XStream）时，可以通过别名映射限制类的加载。
-
升级库和框架：
- 定期升级序列化库和框架，确保使用最新版本的库，以防止已知的反序列化漏洞。
示例：使用白名单
以下是使用白名单防御反序列化攻击的示例：
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectInputStream.FilterInputStream;
import java.io.InputStream;
public class WhitelistedObjectInputStream extends ObjectInputStream {
public WhitelistedObjectInputStream(InputStream in) throws IOException {
super(in);
}
@Override
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
String className = desc.getName();
if (className.equals("com.example.SafeClass")) {
return super.resolveClass(desc);
} else {
throw new ClassNotFoundException("Unauthorized deserialization attempt: " + className);
}
}
}
通过这种方式，可以确保只有安全的类才会被反序列化，其他类将会被拒绝，从而防止反序列化攻击。
反序列化攻击是一种严重的安全威胁，开发者必须采取有效的措施来防范此类攻击。通过避免反序列化不受信任的数据、使用白名单机制、选择安全的库和定期升级框架，可以大大降低反序列化攻击的风险。
tranisent关键字
1. 是什么？
transient 关键字用于标记类的成员变量，使其在序列化过程中被忽略，不会被序列化到字节流中。
2. 实现原理
- 在Java序列化过程中，只有实现了
Serializable接口的类的实例才能被序列化。 - 当Java对象被序列化时，所有的非
transient和非static成员变量的值都会被序列化。 - 反序列化时，
transient变量的值不会被恢复，而是使用该类型的默认值（例如，整型是0，布尔型是false，对象是null）。
3. 为什么要使用？
- 安全性：避免序列化敏感信息，如密码、密钥等。
- 性能：序列化大对象或不必要的信息可能影响性能，通过
transient关键字可以避免序列化这些数据。 - 逻辑控制：有时对象的一部分数据是临时的或派生的，不需要序列化，如缓存数据、临时计算结果等。
4. 实际使用场景
-
敏感信息：如用户密码、信用卡信息等，不希望这些信息被序列化。
public class User implements Serializable { private String username; private transient String password; } -
临时数据：如缓存数据、临时计算结果等，不需要在序列化过程中保存。
public class Session implements Serializable { private String sessionId; private transient long lastAccessTime; } -
不可序列化的对象：如文件流、网络连接等，这些对象无法被序列化，必须标记为
transient。public class FileManager implements Serializable { private transient FileInputStream fileStream; }
5. 最佳实践
-
尽量避免序列化敏感数据：确保敏感信息不会通过序列化泄露。
-
标记不必要序列化的临时数据：提高序列化性能，减少不必要的数据传输。
-
明确序列化需求：清楚了解哪些数据需要被持久化，哪些数据不需要。
-
实现
writeObject和readObject方法：对于复杂对象，可以自定义序列化逻辑来处理transient变量。private void writeObject(ObjectOutputStream oos) throws IOException { oos.defaultWriteObject(); // 手动序列化 transient 变量 oos.writeObject(encrypt(password)); } private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { ois.defaultReadObject(); // 手动反序列化 transient 变量 this.password = decrypt((String) ois.readObject()); }
6. 使用时的注意事项
- 初始值问题：
transient变量在反序列化时会被设置为默认值（如0、false、null等），需要在反序列化后重新初始化。 - 自定义序列化方法：如果有复杂逻辑，仅仅依赖transient关键字是不够的，需要通过实现
writeObject和readObject方法来确保transient变量（比如敏感数据，文件句柄等）的正确处理。 - 类版本控制：在类定义中增加或移除
transient变量时，要确保serialVersionUID的版本控制，以避免反序列化时的兼容性问题。 - 避免滥用：仅对真正需要排除序列化的变量使用
transient关键字，不要过度使用，避免引起数据不完整或逻辑错误。
版本控制
在Java中，序列化版本控制和反序列化版本兼容是通过 serialVersionUID 字段来实现的。serialVersionUID 是一个类版本的唯一标识，用于在序列化和反序列化过程中确保类的版本兼容性。
serialVersionUID
- 定义：
serialVersionUID是一个静态的、最终的长整型字段，用于表示类的序列化版本。
private static final long serialVersionUID = 1L;
- 作用：在序列化和反序列化过程中，JVM 会比较类的
serialVersionUID。如果序列化的对象和反序列化的类的serialVersionUID不一致，会抛出InvalidClassException异常，表示版本不兼容。
版本控制
通过显式声明 serialVersionUID，可以实现对类版本的控制，确保在类发生变化时能够正确地序列化和反序列化对象。
示例
import java.io.Serializable;
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// getters and setters
}
在上述示例中，Person 类的 serialVersionUID 被显式声明为 1L。如果在未来对该类进行修改，可以根据需要更新 serialVersionUID 以实现版本控制。
反序列化版本兼容
为了实现反序列化的版本兼容性，可以采取以下几种策略：
-
保持
serialVersionUID不变：- 如果对类的修改不会影响反序列化（如添加非
transient字段），可以保持serialVersionUID不变，以实现版本兼容。 - 反序列化过程中，新增的字段会被初始化为默认值。
- 如果对类的修改不会影响反序列化（如添加非
-
手动更新
serialVersionUID：- 如果对类的修改会影响反序列化（如删除字段或改变字段类型），需要更新
serialVersionUID，并提供相应的逻辑来处理旧版本的数据。
- 如果对类的修改会影响反序列化（如删除字段或改变字段类型），需要更新
-
自定义序列化方法：
- 通过实现
writeObject和readObject方法，处理版本变化带来的兼容性问题。
- 通过实现
具体实现策略
1. 保持 serialVersionUID 不变
private static final long serialVersionUID = 1L;
private String name;
private int age;
// 新增字段
private String address;
在这个例子中，即使 Person 类新增了 address 字段，由于 serialVersionUID 没有变化，旧版本的对象仍然可以被反序列化，新增字段会被初始化为默认值 null。
2. 手动更新 serialVersionUID
private static final long serialVersionUID = 2L;
private String name;
private int age;
private String address;
如果对类的修改较大（如删除字段），需要更新 serialVersionUID，并提供处理逻辑：
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ois.defaultReadObject();
// 处理反序列化的兼容性逻辑
}
3. 自定义序列化方法
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
private transient String address;
public Person(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
private void writeObject(ObjectOutputStream oos) throws IOException {
oos.defaultWriteObject();
// 自定义序列化逻辑
oos.writeObject(address != null ? address : "");
}
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ois.defaultReadObject();
// 自定义反序列化逻辑
this.address = (String) ois.readObject();
}
// getters and setters
}
注意事项
- 显式声明
serialVersionUID：确保serialVersionUID显式声明，以避免编译器自动生成不同的serialVersionUID导致版本不兼容。 - 谨慎修改类结构：修改类结构时，需要评估对序列化和反序列化的影响，并相应地更新
serialVersionUID。 - 测试兼容性：在版本升级过程中，进行充分的序列化和反序列化测试，确保兼容性问题得到处理。
- 文档记录：在代码注释或项目文档中记录
serialVersionUID的变化及原因，以便团队成员了解类的版本控制情况。
Externalizable接口
Externalizable 和 Serializable 接口的区别
Serializable 接口
- 简介：
Serializable是一个标记接口，没有任何方法。实现这个接口的类可以被 Java 序列化机制自动处理。 - 默认序列化机制：实现
Serializable接口后，Java 的序列化机制会自动处理对象的序列化和反序列化，包括所有非transient和非static字段。 - 灵活性：可以通过实现
writeObject和readObject方法来自定义序列化和反序列化逻辑。
Externalizable 接口
- 简介：
Externalizable是Serializable的子接口，包含两个方法：writeExternal和readExternal。 - 自定义序列化机制：实现
Externalizable接口后，类必须显式定义序列化和反序列化逻辑。 - 效率和控制：提供完全的控制权，可以优化序列化和反序列化过程，选择性地序列化对象的状态。
如何通过实现 Externalizable 接口来自定义序列化和反序列化过程
实现 Externalizable 接口需要实现两个方法：writeExternal 和 readExternal。这两个方法分别用于自定义序列化和反序列化逻辑。
示例代码
import java.io.*;
public class Person implements Externalizable {
private String name;
private int age;
// 必须有无参构造函数
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeUTF(name);
out.writeInt(age);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
this.name = in.readUTF();
this.age = in.readInt();
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
public static void main(String[] args) {
Person person = new Person("Alice", 30);
// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
oos.writeObject(person);
} catch (IOException e) {
e.printStackTrace();
}
// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
Person deserializedPerson = (Person) ois.readObject();
System.out.println("Deserialized Person: " + deserializedPerson);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
为什么要使用 Externalizable
- 完全控制：通过实现
Externalizable，开发者可以完全控制对象的序列化和反序列化过程，而不是依赖默认的序列化机制。 - 性能优化：在一些情况下，可以通过自定义序列化逻辑来优化性能。例如，可以选择性地序列化对象的部分字段或以更高效的方式序列化数据。
- 兼容性：在对象结构发生变化时，可以更好地处理版本兼容问题。例如，通过自定义序列化逻辑来处理新增或删除的字段。
- 安全性：通过自定义序列化，可以更好地保护敏感数据，避免某些字段在序列化过程中被不必要地暴露。
注意事项
- 实现无参构造函数：实现
Externalizable接口的类必须提供一个公共的无参构造函数，以便反序列化过程中能够创建对象实例。 - 处理异常：在
writeExternal和readExternal方法中，需要处理可能的IOException和ClassNotFoundException异常。 - 确保数据一致性：自定义序列化和反序列化逻辑时，需要确保所有必要的字段都被正确序列化和反序列化，以保持对象的一致性和完整性。
总结
Serializable：适用于大多数简单的序列化需求，使用方便，但缺乏对序列化过程的控制。Externalizable：适用于需要完全控制序列化过程的场景，可以优化性能、增强安全性和兼容性，但实现复杂度较高。
对象图的序列化
对象图的序列化
什么是对象图？
对象图是指一个对象及其所有引用对象的集合，形成一个复杂的引用网络。在Java序列化中，对象图包括：
- 被序列化的对象。
- 被序列化对象的所有直接和间接引用的对象。
- 这些对象之间的引用关系。
序列化对象图时的挑战
- 循环引用：当两个或多个对象相互引用时，会形成一个循环引用。这会导致在序列化过程中无限递归的问题。
- 共享对象：当多个对象引用同一个对象时，需要在反序列化过程中保持这个共享对象的引用关系。
如何处理对象图中的循环引用和共享对象
Java的内置序列化机制通过 ObjectOutputStream 和 ObjectInputStream 自动处理循环引用和共享对象。这是通过内部的引用表（reference table）实现的，该表在序列化和反序列化过程中跟踪已经处理过的对象。
示例代码：处理对象图的序列化
以下是一个示例代码，演示如何处理对象图中的循环引用和共享对象：
import java.io.*;
class Node implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private Node next;
public Node(String name) {
this.name = name;
}
public void setNext(Node next) {
this.next = next;
}
@Override
public String toString() {
return "Node{" +
"name='" + name + '\'' +
", next=" + (next != null ? next.name : "null") +
'}';
}
}
public class ObjectGraphSerialization {
public static void main(String[] args) {
// 创建对象图
Node node1 = new Node("node1");
Node node2 = new Node("node2");
Node node3 = new Node("node3");
node1.setNext(node2);
node2.setNext(node3);
node3.setNext(node1); // 循环引用
// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("graph.ser"))) {
oos.writeObject(node1);
} catch (IOException e) {
e.printStackTrace();
}
// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("graph.ser"))) {
Node deserializedNode1 = (Node) ois.readObject();
System.out.println("Deserialized Node: " + deserializedNode1);
System.out.println("Deserialized Node Next: " + deserializedNode1.next);
System.out.println("Deserialized Node Next Next: " + deserializedNode1.next.next);
System.out.println("Deserialized Node Next Next Next: " + deserializedNode1.next.next.next); // 循环引用
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
解释
-
对象图创建：
- 创建了三个
Node对象，并形成了一个包含循环引用的对象图。 node3的next指向node1，形成一个环形结构。
- 创建了三个
-
序列化：
- 使用
ObjectOutputStream将node1对象序列化到文件graph.ser中。 - Java 序列化机制会自动处理对象图中的循环引用和共享对象，避免无限递归。
- 使用
-
反序列化：
- 使用
ObjectInputStream从文件graph.ser中读取node1对象。 - 反序列化过程中，Java 会正确恢复对象图，包括循环引用和共享对象。
- 使用
注意事项
- 避免手动序列化循环引用：尽量避免在自定义
writeObject和readObject方法中手动处理循环引用。Java 内置的序列化机制已经能很好地处理这些问题。 - 共享对象的一致性：确保在序列化和反序列化过程中，引用关系的一致性。例如，在反序列化时共享对象应保持与序列化时相同的引用关系。
- 性能考虑：在处理大型对象图时，序列化和反序列化的性能可能成为瓶颈。可以考虑优化对象图结构或采用更高效的序列化机制（如Google的Protobuf或Kryo）。
思考🤔️：json中也存在循环引用，java序列化的处理机制有什么借鉴思想
序列化性能优化
序列化和反序列化的性能影响因素
- 对象的复杂性：对象图的深度和广度会直接影响序列化和反序列化的性能。对象包含的字段越多、层次越深，性能消耗越大。
- I/O 操作：序列化和反序列化过程涉及到文件读写或网络传输，I/O 操作的速度是影响性能的关键因素。
- 数据量：对象的大小及其包含的数据量决定了序列化生成的数据流的大小，数据量越大，序列化和反序列化的时间越长。
- 序列化机制：不同的序列化机制（如Java原生序列化、JSON、Protobuf等）的效率不同。原生序列化在速度和数据大小方面通常不如一些优化过的第三方序列化库。
性能优化技巧
1. 使用序列化代理
序列化代理模式通过使用一个简单的代理对象来代替复杂对象进行序列化，以减少序列化和反序列化的开销。
示例：
import java.io.*;
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
private Object writeReplace() throws ObjectStreamException {
return new PersonProxy(name, age);
}
private static class PersonProxy implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
PersonProxy(String name, int age) {
this.name = name;
this.age = age;
}
private Object readResolve() throws ObjectStreamException {
return new Person(name, age);
}
}
// Getters and toString method
}
2. 自定义序列化形式
通过实现 Serializable 接口并定义 writeObject 和 readObject 方法，可以自定义序列化和反序列化逻辑，以优化性能。
示例：
import java.io.*;
public class Employee implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
private transient String address; // large field
public Employee(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
private void writeObject(ObjectOutputStream oos) throws IOException {
oos.defaultWriteObject();
oos.writeUTF(address != null ? address : "");
}
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ois.defaultReadObject();
this.address = ois.readUTF();
}
// Getters and toString method
}
3. 使用高效的第三方序列化库
Java 原生序列化在性能上可能不如一些优化过的第三方序列化库。可以考虑使用这些库来提高性能。
- Google Protocol Buffers (Protobuf)：高效、结构化的数据序列化机制。
- Kryo：快速、紧凑的序列化库，适用于高性能要求的场景。
- Jackson：高性能的 JSON 处理库，可以用来序列化和反序列化 JSON 数据。
示例：使用 Kryo 进行序列化和反序列化
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class KryoExample {
public static void main(String[] args) {
Kryo kryo = new Kryo();
Employee employee = new Employee("John", 30, "123 Main St");
// 序列化
try (Output output = new Output(new FileOutputStream("employee.bin"))) {
kryo.writeObject(output, employee);
} catch (IOException e) {
e.printStackTrace();
}
// 反序列化
try (Input input = new Input(new FileInputStream("employee.bin"))) {
Employee deserializedEmployee = kryo.readObject(input, Employee.class);
System.out.println("Deserialized Employee: " + deserializedEmployee);
} catch (IOException e) {
e.printStackTrace();
}
}
}
总结
- 对象的复杂性和数据量：尽量简化对象结构，避免不必要的嵌套和过多的字段。
- I/O 操作：优化 I/O 操作，使用高效的 I/O 流（如 NIO），并尽量减少 I/O 操作次数。
- 序列化机制选择：选择高效的序列化机制，必要时使用第三方序列化库。
- 自定义序列化：通过实现
writeObject和readObject方法，或者使用序列化代理，优化序列化和反序列化的性能。
序列化安全性
序列化和反序列化的安全性
序列化和反序列化的安全风险
- 对象篡改：恶意用户可以篡改序列化的数据，注入恶意对象或改变对象的状态，导致应用程序行为异常或执行恶意代码。
- 远程代码执行：在反序列化过程中，如果包含恶意对象，可以触发远程代码执行漏洞，允许攻击者在受害系统上执行任意代码。
- 拒绝服务攻击：大规模或复杂的序列化数据可以导致反序列化过程耗尽系统资源，导致拒绝服务（DoS）攻击。
防范序列化和反序列化的安全漏洞
- 使用安全的序列化库
- 实施对象签名验证
- 限制反序列化对象
- 采用白名单机制
- 避免反序列化未受信任的数据
1. 使用安全的序列化库
使用第三方序列化库，如 Google Protocol Buffers (Protobuf)、Kryo 或 Jackson，这些库通常经过安全审计，并提供更严格的序列化和反序列化控制。
示例：使用 Protobuf 进行序列化和反序列化
// Employee.proto
syntax = "proto3";
message Employee {
string name = 1;
int32 age = 2;
string address = 3;
}
生成 Java 类：
protoc --java_out=. Employee.proto
使用 Protobuf 进行序列化和反序列化：
import com.example.EmployeeProtos.Employee;
import com.google.protobuf.InvalidProtocolBufferException;
public class ProtobufExample {
public static void main(String[] args) {
Employee employee = Employee.newBuilder()
.setName("John")
.setAge(30)
.setAddress("123 Main St")
.build();
// 序列化
byte[] data = employee.toByteArray();
// 反序列化
try {
Employee deserializedEmployee = Employee.parseFrom(data);
System.out.println("Deserialized Employee: " + deserializedEmployee);
} catch (InvalidProtocolBufferException e) {
e.printStackTrace();
}
}
}
2. 实施对象签名验证
在序列化数据中添加签名，并在反序列化时验证签名，以确保数据未被篡改。
示例：使用签名验证
import java.io.*;
import java.security.*;
public class SignedObjectExample {
public static void main(String[] args) throws Exception {
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
keyGen.initialize(2048);
KeyPair pair = keyGen.generateKeyPair();
PrivateKey privateKey = pair.getPrivate();
PublicKey publicKey = pair.getPublic();
// 序列化对象并签名
Person person = new Person("Alice", 25);
byte[] data = serialize(person);
Signature signature = Signature.getInstance("SHA256withRSA");
signature.initSign(privateKey);
signature.update(data);
byte[] signedData = signature.sign();
// 反序列化对象并验证签名
Signature signatureVerify = Signature.getInstance("SHA256withRSA");
signatureVerify.initVerify(publicKey);
signatureVerify.update(data);
boolean isValid = signatureVerify.verify(signedData);
if (isValid) {
Person deserializedPerson = (Person) deserialize(data);
System.out.println("Deserialized Person: " + deserializedPerson);
} else {
System.out.println("Signature verification failed.");
}
}
private static byte[] serialize(Object obj) throws IOException {
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
try (ObjectOutputStream out = new ObjectOutputStream(byteOut)) {
out.writeObject(obj);
}
return byteOut.toByteArray();
}
private static Object deserialize(byte[] data) throws IOException, ClassNotFoundException {
ByteArrayInputStream byteIn = new ByteArrayInputStream(data);
try (ObjectInputStream in = new ObjectInputStream(byteIn)) {
return in.readObject();
}
}
private static class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + '}';
}
}
}
3. 限制反序列化对象
在反序列化过程中，通过设置对象输入流的自定义过滤器，限制反序列化的类。
示例：使用对象输入流过滤器
import java.io.*;
public class ObjectInputFilterExample {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Employee employee = new Employee("John", 30, "123 Main St");
// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("employee.ser"))) {
oos.writeObject(employee);
}
// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("employee.ser"))) {
ois.setObjectInputFilter(info -> {
if (info.serialClass() == null) return ObjectInputFilter.Status.UNDECIDED;
if (info.serialClass() == Employee.class) return ObjectInputFilter.Status.ALLOWED;
return ObjectInputFilter.Status.REJECTED;
});
Employee deserializedEmployee = (Employee) ois.readObject();
System.out.println("Deserialized Employee: " + deserializedEmployee);
}
}
private static class Employee implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
private String address;
Employee(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
@Override
public String toString() {
return "Employee{name='" + name + "', age=" + age + ", address='" + address + "'}";
}
}
}
4. 采用白名单机制
采用白名单机制仅允许特定类进行反序列化，避免反序列化恶意对象。
示例：
import java.io.*;
import java.util.*;
public class WhitelistClassResolver {
private static final Set<String> allowedClasses = new HashSet<>(Arrays.asList(
"com.example.Employee"
));
public static void main(String[] args) throws IOException, ClassNotFoundException {
Employee employee = new Employee("John", 30, "123 Main St");
// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("employee.ser"))) {
oos.writeObject(employee);
}
// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("employee.ser"))) {
Employee deserializedEmployee = (Employee) ois.readObject();
if (!allowedClasses.contains(deserializedEmployee.getClass().getName())) {
throw new ClassNotFoundException("Class not allowed for deserialization");
}
System.out.println("Deserialized Employee: " + deserializedEmployee);
}
}
private static class Employee implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
private String address;
Employee(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
@Override
public String toString() {
return "Employee{name='" + name + "', age=" + age + ", address='" + address + "'}";
}
}
}
5. 避免反序列化未受信任的数据
- 避免从不受信任的来源读取序列化数据：限制数据来源，确保数据来源可信。
- 使用加密：对序列化数据进行加密和解密，防止数据篡改和泄露。
其他技术
序列化和反序列化的其他技术
JSON序列化
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式。它易于阅读和编写，同时也易于机器解析和生成。JSON 序列化和反序列化广泛用于 Web 开发、微服务通信和配置文件。
优点
- 可读性强：JSON 格式直观，易于阅读和调试。
- 跨语言支持：几乎所有编程语言都支持 JSON 解析和生成。
- 广泛使用：广泛应用于 REST API、配置文件等场景。
缺点
- 性能较低：相比二进制序列化，JSON 的性能较低，尤其在数据量大时。
- 数据类型支持有限：不支持复杂的数据类型，如时间、二进制数据等。
示例：使用 Jackson 进行 JSON 序列化和反序列化
import com.fasterxml.jackson.databind.ObjectMapper;
public class JsonExample {
public static void main(String[] args) {
ObjectMapper objectMapper = new ObjectMapper();
Employee employee = new Employee("John", 30, "123 Main St");
try {
// 序列化
String jsonString = objectMapper.writeValueAsString(employee);
System.out.println("Serialized JSON: " + jsonString);
// 反序列化
Employee deserializedEmployee = objectMapper.readValue(jsonString, Employee.class);
System.out.println("Deserialized Employee: " + deserializedEmployee);
} catch (Exception e) {
e.printStackTrace();
}
}
private static class Employee {
private String name;
private int age;
private String address;
public Employee() {}
public Employee(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
@Override
public String toString() {
return "Employee{name='" + name + "', age=" + age + ", address='" + address + "'}";
}
}
}
XML序列化
XML（eXtensible Markup Language）是一种标记语言，设计用于传输和存储数据。XML 序列化和反序列化主要用于配置文件、文档格式以及一些遗留系统中。
优点
- 自描述：XML 数据具有自描述性，标签清晰地描述了数据内容。
- 可扩展性：XML 支持复杂的数据结构，可以包含属性、嵌套元素等。
- 标准化：XML 是一种广泛接受的标准，支持良好。
缺点
- 冗长：XML 比 JSON 冗长，数据量大时，占用更多的带宽和存储空间。
- 性能较低：解析和生成 XML 的性能较低。
示例：使用 JAXB 进行 XML 序列化和反序列化
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.StringReader;
import java.io.StringWriter;
public class XmlExample {
public static void main(String[] args) {
try {
JAXBContext context = JAXBContext.newInstance(Employee.class);
Employee employee = new Employee("John", 30, "123 Main St");
// 序列化
Marshaller marshaller = context.createMarshaller();
StringWriter writer = new StringWriter();
marshaller.marshal(employee, writer);
String xmlString = writer.toString();
System.out.println("Serialized XML: " + xmlString);
// 反序列化
Unmarshaller unmarshaller = context.createUnmarshaller();
StringReader reader = new StringReader(xmlString);
Employee deserializedEmployee = (Employee) unmarshaller.unmarshal(reader);
System.out.println("Deserialized Employee: " + deserializedEmployee);
} catch (JAXBException e) {
e.printStackTrace();
}
}
private static class Employee {
private String name;
private int age;
private String address;
public Employee() {}
public Employee(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
@Override
public String toString() {
return "Employee{name='" + name + "', age=" + age + ", address='" + address + "'}";
}
}
}
选择合适的序列化方式
在选择序列化方式时，需要考虑以下因素：
-
数据格式
- JSON：适用于需要人类可读性和跨语言兼容性的场景，如 Web 开发、REST API 等。
- XML：适用于需要复杂数据结构和自描述性的场景，如配置文件、文档格式等。
- 二进制：适用于性能和空间要求高的场景，如分布式系统、实时数据传输等。
-
性能需求
- 高性能：选择二进制序列化方式，如 Protobuf、Kryo 等。
- 中等性能：JSON 序列化性能中等，适用于大多数 Web 应用场景。
- 低性能：XML 序列化性能较低，但适用于需要复杂数据结构和自描述性的场景。
-
兼容性
- 跨语言兼容：选择 JSON 或 Protobuf，几乎所有编程语言都支持。
- 平台兼容：选择 XML 或 JSON，支持广泛的技术栈和平台。
-
数据复杂性
- 简单数据结构：选择 JSON 或 Protobuf，易于使用和解析。
- 复杂数据结构：选择 XML，支持嵌套、属性等复杂数据结构。
872
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
