“感谢您阅读本篇博客！如果您觉得本文对您有所帮助或启发，请不吝点赞和分享给更多的朋友。您的支持是我持续创作的动力，也欢迎留言交流，让我们一起探讨技术，共同成长！谢谢！🚀✨”
序列化其实就是将数据转化成一种可逆的数据结构，自然，逆向的过程就叫做反序列化，序列化与反序列化的根本目的是数据的传输
序列化以反序列化
Java序列化是指把Java对象转换为字节序列的过程,将数据分解成字节流以便存储在文件中或在网络上传输；而Java反序列化是指把字节序列恢复为Java对象的过程,打开字节流并重构对象
序列化：对象 -> 字符串(字节流)
反序列化：字符串字符串(字节流) -> 对象
比如：现在我们都会在淘宝上买桌子，桌子这种很不规则的东西，该怎么从一个城市运输到另一个城市，这时候一般都会把它拆掉成板子，再装到箱子里面，就可以快递寄出去了，这个过程就类似我们的序列化的过程（把数据转化为可以存储或者传输的形式）。当买家收到货后，就需要自己把这些板子组装成桌子的样子，这个过程就像反序列的过程（转化成当初的数据对象）
ObjectOutputStream 序列化
// 创建序列化对象oss
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
// 创建好反序列化对象oss后使用ObjectOutputStream类自带的writeObject方法,
//将指定对象序列化写入输出流 writeObject方法传入的对象会转化 为字节流将对象的状态保存到文件中
oos.writeObject(obj);
ObjectInputStream 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
// 调用反序列化对象中的readObject从输入流中读取对象的字节流，并将其反序列化为对象。
// 读取对象的字节表示形式，并将其转换为Java对象
Object obj = ois.readObject();
// 返回 反序列化后的对象
return obj;
为什么需要序列化
网站中两个进程进行远程通信，互相发送各种类型的数据,图片 视频 文档,这些数据会以二进制序列形式进行传递,使用Java 序列化和反序列化实现进程间对象传送
发送方将发送的数据对象转换为Java字节序列,拆分为字节流 序列化过程
接收方将收到的数据从字节流重构转化为当初的数据读性对象
Serializable接口序列化
接口Serializable
序列化接口Serializable接口是一个标识接口，它的主要作用就是标识这个对象是可序列化, 接口应该使用Java标准库中的java.io.Serializable而不是自定义的a.Serializable接口
有实现了Serializable或者Externalizable接口的类的对象才能被序列化为字节序列。（不是则会抛出异常; 实现Serializable接口，类表明它是可序列化的，可以被ObjectOutputStream序列化，以及被ObjectInputStream反序列化
// 实现Serializable 接口的类才可以被序列化/反序列化,自定义的无法使用需要使用库内自带的
public interface Serializable {
// 实现即可无须写入什么东西
}
实现代码
person.java 实现对象类
import java.io.Serializable; // 需要实现的是自带的接口
// 类实现Serializable接口才能序列化
public class person implements Serializable {
private String name;
private int age;
public person(){
}
// 有参构造器
public person(String name, int age){
this.name = name;
this.age = age;
}
@Override
// 自带方法
public String toString(){
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
SerializationTest.java 序列化文件类
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
public class SerializationTest {
// 静态方法将传入的对象序列化并写入到ser.bin 文件中
// 并且里面有一个形参用与在下文中使用此方法传递对象进去
public static void serialize(Object obj) throws IOException{
// 创建序列化对象oss
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
// 创建好反序列化对象oss后使用ObjectOutputStream类自带的writeObject方法,将指定对象序列化写入输出流
// writeObject方法传入的对象会转化 为字节流将对象的状态保存到文件中
oos.writeObject(obj);
}
public static void main(String[] args) throws Exception{
person person = new person("aa",22); //实例化类 使用User类 有参构造器
System.out.println(person); // 打印对象会调用类里面的toString()方法输出值
serialize(person); // 调用上文序列化方法将实例化的对象传入
}
}
-----------------------------------------------
输出:
Person{name='aa', age=22}
UnserializeTest.java反序列化文件类
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class UnserializeTest {
// 形参为 文件名
public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
// 创建一个反序列化对象 ois将其关联到名为Filename的文件输出流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
// 调用反序列化对象中的readObject从输入流中读取对象的字节流，并将其反序列化为对象。
// 读取对象的字节表示形式，并将其转换为Java对象
Object obj = ois.readObject();
// 返回 反序列化后的对象
return obj;
}
public static void main(String[] args) throws Exception{
// 调用上文的unserialize方法传入实参需要被反序列化的文件,然后将其转换为person对象,
// 先转换 将返回的反序列化后的person对象赋值给了person变量，实现了从文件中恢复对象的操作。
person person = (person)unserialize("ser.bin");
// 打印该person转换后的对象，这里会调用person类的toString()方法来输出对象的字符串表示形式。
System.out.println(person);
}
}
-----------------------------------------------
输出:
Person{name='aa', age=22}
序列化注意点
反序列化过程中，它的父类如果没有实现序列化接口，那么将需要提供无参构造函数来重新创建对象
序列化的对象是已经继承了其他类变成了子类的化,如果父类没有实现接口Serializable,那么父类要么选择实现这个接口,要么是提供无参构造器,在反序列化Child对象时，Java会调用Parent类的无参构造函数来重新创建Parent对象。
import java.io.Serializable;
public class Parent {
private int id;
public Parent() {
// 提供无参构造函数
}
public Parent(int id) {
this.id = id;
}
}
// 继承了Parent类并实现了Serializable接口
public class Child extends Parent implements Serializable {
private String name;
public Child(String name, int id) {
super(id);
this.name = name;
}
}
实现 Serializable接口的子类也是可以被序列化的
当一个父类类实现了Serializable接口，它的子类也会自动被序列化。这意味着，如果一个父类实现了Serializable接口，那么它的所有子类都可以被序列化，无需再单独实现Serializable接口;即子类也被视为可序列化的。这样可以确保整个继承层次结构在序列化和反序列化过程中的一致性。
import java.io.Serializable;
public class Parent implements Serializable {
private int id;
public Parent(int id) {
this.id = id;
}
// 其他类内容
}
public class Child extends Parent {
private String name;
public Child(String name, int id) {
super(id);
this.name = name;
}
// 其他类内容
}
静态成员变量是不能被序列化 序列化是针对对象属性的，而静态成员变量是属于类的
静态成员变量属于类级别而不是实例级别，它们不会被包含在序列化的过程中。当对象被序列化时，只有实例变量会被保存到序列化的数据流中，静态成员变量不会被包含在序列化的数据中,。如果需要在序列化过程中保存静态成员变量的状态，可以通过自定义序列化和反序列化方法来实现。
import java.io.Serializable; // 导入Serializable接口
public class MyClass implements Serializable { // MyClass类实现Serializable接口
private static int staticVar = 10; // 静态成员变量staticVar 不会被序列化
private int instanceVar; // 实例成员变量instanceVar
public MyClass(int instanceVar) { // MyClass类的构造函数
this.instanceVar = instanceVar; // 初始化实例成员变量instanceVar
}
public static void main(String[] args) { // 主方法
MyClass obj = new MyClass(20); // 创建MyClass对象obj
// 将对象序列化的过程
// 省略序列化代码
}
}
transient 标识的对象成员变量不参与序列化
一个对象的成员变量被标记为transient时，在对象进行序列化时，这些被标记的成员变量将不会被序列化，即它们的值不会被保存到序列化的数据流中。只会参与这个过程并输出对应数据类型的默认值,int类型输出**0** ,但原始对象中的值并没有改变,仍然是**30**，只要添加了transient，序列化运行时会跳过该字段的处理。
package a;
import java.io.*;
// 实现 Serializable接口
class Person implements Serializable {
private String name;
private transient int age; // 使用transient关键字标记age成员变量不被序列化
// 构造函数
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class SerializationExample {
public static void main(String[] args) {
// 实例化类person
Person person = new Person("Alice", 30);
try {
// 将对象序列化到文件
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.ser"));
out.writeObject(person);
out.close();
// 从文件中反序列化对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.ser"));
Person deserializedPerson = (Person) in.readObject();
in.close();
// 输出反序列化后的对象
System.out.println(deserializedPerson);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
--------------------------------------
Person{name='Alice', age=0}
// 0 就是age默认的的值,但实际的数据并没有受到影响
// 这在某些情况下很有用，比如某些敏感信息或临时数据不需要被序列化保存
Externalizable接口序列化
参考文章:
Java 序列化之 Externalizable-腾讯云开发者社区-腾讯云 (tencent.com)
接口Externalizable
JDK中除了提供 Serializable 序列化接口外，还提供了另一个序列化接口Externalizable，使用该接口之后，之前基于Serializable接口的序列化机制就将失效。Externalizable 的序列化机制优先级要高于 Serializable
源码中Externalizable 接口继承了 Serializable接口，并定义了两个方法,实现此接口后，类中属性字段使用 transient 和不使用没有任何区别
writeExterna(写入 userName 和 password 两个数据)
readExternal(读取反序列化的信息并赋值给 userName 和 password 两个字段)
 {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
// 输出自带的方法打印字符串查看效果
return "User [userName=" + userName + ", password=" + password + "]";
}
// 下面的两个方法是需要填写数据的
// 在 writeExternal 方法中写入 userName 和 password 两个数据，
// readExternal 方法中读取反序列化的信息并赋值给 userName 和 password 两个字段。
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(this.userName); // 保存属性
out.writeObject(this.password);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
this.userName = in.readObject().toString(); // 读取属性
this.password = in.readObject().toString();
}
}
Test.java
import java.io.*;
public class Test{
public static void main(String[] args) throws Exception {
// 创建文件对象给出路径和名称 1.txt 把变量给file
File file = new File("d:\\a.user");
// 序列化过程
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
User user1 = new User(); // 实例化上文的 User类
user1.setUserName("zhangsan"); // 赋值
user1.setPassword("123456"); // 赋值
oos.writeObject(user1);
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
User user2 = (User) ois.readObject();
System.out.println(user2);
}
}
-----------------------------------------
输出:
User [userName=zhangsan, password=123456]
序列化注意点
Externalizable 进行反序列化时，需要有默认的构造方法,有参的构造器是不够的,还需要自己手写一个默认无参的构造器, 因为使用 Externalizable 进行反序列化时，需要有默认的构造方法，通过反射先创建出该类的实例，然后再把解析后的属性值，通过反射赋值。
Serializable接口则不需要单独写默认无参的构造器
public class User implements Externalizable {
// 序列ID
private static final long serialVersionUID = 1318824539146791009L;
private String userName;
private transient String password;
// 无参/默认构造器
public User(){
}
// 有参构造器
public User(String userName, String password) {
super();
this.userName = userName;
this.password = password;
}
}
User.java
package a;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
public class User implements Externalizable {
// 序列ID
private static final long serialVersionUID = 1318824539146791009L;
private String userName;
private transient String password;
// 无参/默认构造器
public User(){
}
// 有参构造器
public User(String userName, String password) {
super();
this.userName = userName;
this.password = password;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User [userName=" + userName + ", password=" + password + "]";
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(this.userName);
out.writeObject("externalizable:"+this.password);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
this.userName = (String)in.readObject();
this.password = (String)in.readObject();
}
}
Test.java
package a;
import java.io.*;
public class Test{
public static void main(String[] args) throws Exception {
File file = new File("d:\\a.user");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
// 通过User类的有参构造器
User user1 = new User("zhangsan", "123456");
oos.writeObject(user1); // 序列对象过程
System.out.println(oos);
System.out.println("-------序列化成功");
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
User user2 = (User) ois.readObject();
System.out.println(user2);
System.out.println("-------反序列化成功");
}
}
--------------------------------
输出:
-------序列化成功
User [userName=zhangsan, password=externalizable:123456]
-------反序列化成功
序列化安全
序列化安全主要是由于writeObject() readObject()这两种方法是可以通过开发者重写的,重写的场景一般是这样的
假设有一个名为MyList的类，其中定义了一个名为arr的数组属性，初始数组长度为100。在实际序列化过程中，如果让arr属性参与序列化，那么整个长度为100的数组都会被序列化,但是数组中存放的数据只有50个数据,如果整个数组全部序列化的数据量过大且浪费空间,所以需要重写方法自定义序列化过程
在上文代码的基础上加入重写的readObject反序列化方法,然后按照顺序运行序列化程序 SerializationTest.java 再运行反序列化程序 UnserializeTest.java,会执行重写的方法并且执行外部命令弹出计算机calc,这是最理想的情况,但是此情况几乎不会出现
入口参数中包含可控类，该类有危险方法，readObject时调用
入口类参数中包含可控类，该类又调用其他有危险方法的类，readObject时调用
构造函数/静态代码块等类加载时隐式执行
person.java 实现对象类
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable; // 需要实现的是自带的接口
// 类实现Serializable接口才能序列化
public class person implements Serializable {
private String name;
private int age;
public person(){
}
// 构造函数
public person(String name, int age){
this.name = name;
this.age = age;
}
@Override
// 自带方法
public String toString(){
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
// 使用自定义反序列化的readObject方法,形参是指读取序列化的参数,传入的对象就是需要被反序列的东西
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
// defaultReadObject 于从对象流中读取对象的字段。这个方法会读取对象的所有字段，并且将它们设置到对象中
// 恢复对象的状态。
ois.defaultReadObject();
// 执行外部命令弹出计算机
Runtime.getRuntime().exec("calc");
}
}