一.概念
Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。将程序中的对象，放入文件中保存就是序列化，将文件中的字节码重新转成对象就是反序列化
二.要求
只有实现了Serializable或Externalizable接口的类的对象才能被序列化，并且序列化对象的所有属性都需是可序列化的。
三.实现
serializable接口
1.1方法
序列化：创建一个ObjectOutputStream输出流，调用 ObjectOutputStream 对象的 writeObject() 输出可序列化对象
反序列化:创建一个ObjectInputStream输出流，调用 ObjectInputStream 对象的 readObject()得到反序列化的对象
1.2代码
import java.io.*;
import java.lang.reflect.Method;
class User implements Serializable{
private String name;
private int age;
@Override
public String toString(){
return "User{" + "name=" +name + ", age="+age+"}";
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}
public class Main {
public static void main(String[] args) throws Exception {
ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("E:\\tao.txt"));
//创建一个ObjectOutputStream流，将序列化对象输出到tao.txt
User user=new User();
user.setName("tao");
user.setAge(20);
//实例化User
out.writeObject(user);
ObjectInputStream in=new ObjectInputStream(new FileInputStream("E:\\tao.txt"));
// 创建一个 ObjectOutputStream 输出流
User tao=(User)in.readObject();
//将readObject反序列化的结果转化成User类，实例成tao
System.out.println(tao);
}
}
User{name=tao, age=20}
1.3注意
①如果实现 Serializable 接口的类有父类，则父类也必须可以序列化，若父类没有实现序列化接口，则父类必须有无参构造函数，否则会抛异常 java.io.InvalidClassException。因为在父类没有实现 Serializable 接口时，虚拟机是不会序列化父对象的，而一个 Java 对象的构造必须先有父对象，才有子对象，反序列化也不例外。所以反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时，它的值是调用父类无参构造函数后的值。如果没有在父类无参构造函数中对父类变量进行初始化的话，父类变量值都是默认声明的值，如 int 型的默认是 0，string 型的默认是 null。
②序列化不保存静态变量，因为序列化保存的是对象的状态而不是类的状态，静态变量是类的状态
③ 使用transient 关键字可以选择不需要序列化的字段
如:
private transient String name;
private transient int age;进行序列化的时候，name和age都不会被保存
Externalizable接口
2.1注意
①Externalizable接口继承Serializable 接口
②writeExternal()和readExternal()对应writeObject()和readObject()两个方法
③Externalizable序列化没有属性限制，静态变量以及transient 关键字修饰的属性都能被序列化
④必须提供public的无参构造方法，因为在反序列化实现 Externalizabale 接口的类的时需要通过反射创建对象。如果没有无参数的构造方法，在运行时会抛出异常：java.io.InvalidClassException
2.2代码
import java.io.*;
import java.lang.reflect.Method;
class User implements Externalizable{
private String name;
private int age;
public User()
{
}//加上public无参构造器
@Override
public String toString(){
return "User{" + "name=" +name + ", age="+age+"}";
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override//重写writeExternal()方法
public void writeExternal(ObjectOutput out) throws IOException{
out.writeObject(name);
}
@Override//重写wreadExternal()方法
public void readExternal(ObjectInput in) throws IOException,ClassNotFoundException{
name=(String)in.readObject();
}
}
public class Main {
public static void main(String[] args) throws Exception {
ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("E:\\tao.txt"));
//创建一个ObjectOutputStream流，将序列化对象输出到tao.txt
User user=new User();
user.setName("tao");
user.setAge(20);
//实例化User
out.writeObject(user);
ObjectInputStream in=new ObjectInputStream(new FileInputStream("E:\\tao.txt"));
// 创建一个 ObjectOutputStream 输出流
User tao=(User)in.readObject();
//将readObject反序列化的结果转化成User类，实例成tao
System.out.println(tao);
}
}result
User{name=tao, age=0}age变成了0
因为使用Externalizable接口，需要重写writeExternal() 与 readExternal() 方法，我只写了name的实现，没有写age，int型默认值为0
四.安全
java反序列化会自动触发readObject()方法，类似于php反序列化的__destruct()函数
java支持自定义writeObject()和readObject()方法
如果某个类中自定义了readObject()方法，当对其的一个实例化对象进行反序列化，就会调用readObject()方法
import java.io.*;
import java.lang.reflect.Method;
class User implements Serializable{
private String name;
private int age;
@Override
public String toString(){
return "User{" + "name=" +name + ", age="+age+"}";
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
private void readObject(ObjectInputStream in){
System.out.println("这是新的readObject!");
}
}
public class Main {
public static void main(String[] args) throws Exception {
ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("E:\\tao.txt"));
//创建一个ObjectOutputStream流，将序列化对象输出到tao.txt
User user=new User();
user.setName("tao");
user.setAge(20);
//实例化User
out.writeObject(user);
ObjectInputStream in=new ObjectInputStream(new FileInputStream("E:\\tao.txt"));
// 创建一个 ObjectOutputStream 输出流
User tao=(User)in.readObject();
//将readObject反序列化的结果转化成User类，实例成tao
System.out.println(tao);
}
}结果
这是新的readObject!
User{name=null, age=0}可见在反序列化的时候实现了新的readObject()
那么就可以命令执行了
private void readObject(ObjectInputStream in) throws IOException{
Runtime.getRuntime().exec("calc");
}
弹计算器了！
这里初步了解java序列化与反序列话，后续构造链会继续学习。
参考博客
java基础知识点2：序列化与反序列化详解_java序列化和反序列化-CSDN博客
javasec/2.java序列化与反序列化.md at master · Maskhe/javasec (github.com)
