文章目录:
1.序列化和反序列化的概念
把对象转换为字节序列的过程称为对象的序列化。
把字节序列恢复为对象的过程称为对象的反序列化。对象的序列化主要有两种用途:
1) 把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中;
2) 在网络上传送对象的字节序列。在很多应用中,需要对某些对象进行序列化,让它们离开内存空间,入住物理硬盘,以便长期保存。比如最常见的是Web服务器中的Session对象,当有 10万用户并发访问,就有可能出现10万个Session对象,内存可能吃不消,于是Web容器就会把一些seesion先序列化到硬盘中,等要用了,再把保存在硬盘中的对象还原到内存中。
当两个进程在进行远程通信时,彼此可以发送各种类型的数据。无论是何种类型的数据,都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再恢复为Java对象。
2.JDK类库中有关序列化和反序列化的API
java.io.ObjectOutputStream代表对象输出流,它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化,把得到的字节序列写到一个目标输出流中。
java.io.ObjectInputStream代表对象输入流,它的readObject()方法从一个源输入流中读取字节序列,再把它们反序列化为一个对象,并将其返回。
只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口,实现Externalizable接口的类完全由自身来控制序列化的行为,而仅实现Serializable接口的类可以 采用默认的序列化方式 。
对象序列化包括如下步骤:
1) 创建一个对象输出流,它可以包装一个其他类型的目标输出流,如文件输出流;
2) 通过对象输出流的writeObject()方法写对象。对象反序列化的步骤如下:
1) 创建一个对象输入流,它可以包装一个其他类型的源输入流,如文件输入流;
2) 通过对象输入流的readObject()方法读取对象。
3.实例一:序列化单个对象
首先写一个Student实体类
package com.songzihao.bean;
import java.io.Serial;
import java.io.Serializable;
/**
*
*/
public class Student implements Serializable {
@Serial
private static final long serialVersionUID = 3766644755010787032L;
private Integer id;
private String name;
public Student() {
}
public Student(Integer id, String name) {
this.id = id;
this.name = name;
}
//getter and setter
//toString
}
执行序列化操作。
package com.songzihao.bean;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
* 1.参与序列化和反序列化的对象,必须实现 java.io.Serializable 接口
* public interface Serializable {
* }
* 这是一个标志性接口,其中什么方法也没有,起到了标识标志的作用
* Serializable接口是给Java虚拟机参考的,Java虚拟机看到这个接口之后,会为这个类自动生成一个序列化版本号
*/
public class ObjectOutputStreamTest {
public static void main(String[] args) throws IOException {
Student student=new Student(666,"张起灵");
//序列化
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("student"));
//序列化对象
oos.writeObject(student);
//刷新
oos.flush();
//关闭
oos.close();
}
}
执行反序列化操作。
package com.songzihao.bean;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
*
*/
public class ObjectInputStreamTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//反序列化
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("student"));
Student student= (Student) ois.readObject();
//反序列化回来的是一个Java对象,所以这里调用了对象的toString方法
System.out.println(student);
//关闭
ois.close();
}
}
4.实例二:序列化多个对象(一个List集合)
首先写一个User实体类。
package com.songzihao.entity;
import java.io.Serial;
import java.io.Serializable;
/**
*
*/
public class User implements Serializable {
@Serial
private static final long serialVersionUID = -3558401670195225456L;
private Integer id;
//transient关键字表示游离的,不参与序列化
private transient String name;
public User() {
}
public User(Integer id, String name) {
this.id = id;
this.name = name;
}
//getter and setter
//toString
}
执行序列化操作。
package com.songzihao.entity;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
/**
*
*/
public class ObjectOutputStreamTest {
public static void main(String[] args) throws IOException {
//创建一个List集合
List<User> userList=new ArrayList<>();
userList.add(new User(1,"张起灵"));
userList.add(new User(2,"小哥"));
userList.add(new User(3,"闷油瓶"));
//序列化多个对象
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("userList"));
oos.writeObject(userList);
oos.flush();
oos.close();
}
}
执行反序列化操作。
package com.songzihao.entity;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.List;
/**
*
*/
public class ObjectInputStreamTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("userList"));
List<User> userList= (List<User>) ois.readObject();
for (User user : userList) {
System.out.println(user);
}
ois.close();
}
}
5.实例三:关于序列化版本号
在上面两个实例中,我们会看到实体类中总会出现这样一行代码:
private static final long serialVersionUID = -3558401670195225456L;
这个东西其实就是序列化版本号,那么为什么实现 Serializable 接口的类都需要有一个这样的序列化版本号呢?
下面我们先来看一下如果不添加序列化版本号会出现什么问题。
5.1 不添加序列化版本号
package com.songzihao.domain;
import java.io.Serial;
import java.io.Serializable;
public class Person implements Serializable {
//Java虚拟机看到实现Serializable接口之后,会自动生成一个序列化版本号
//假设这两个属性是十年前写好的
private String name;
private String sex;
private Integer age;
public Person() {
}
public Person(String name, String sex) {
this.name = name;
this.sex = sex;
}
//getter and setter
//toString
}
依次执行序列化和反序列化操作。
package com.songzihao.domain;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
*
*/
public class ObjectOutputStreamTest {
public static void main(String[] args) throws IOException {
Person person=new Person("张起灵","男");
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("person"));
oos.writeObject(person);
oos.flush();
oos.close();
}
}
package com.songzihao.domain;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
public class ObjectInputStreamTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("person"));
Person person= (Person) ois.readObject();
System.out.println("person = " + person);
ois.close();
}
}
可以在上面的输出结果中,看到正确无误的实现了序列化和反序列化操作。
那么假如说,这个Person实体类是我昨天编写的,其中只有 name、age、sex三个属性,到今天,我突然想给这个类添加一个 hobby 属性,然后再次执行反序列化操作行不行呢?(因为我们已经执行过序列化操作了,所以这里只需要执行反序列化操作,看看能不能从硬盘中拿到最新的类文件中的内容就行了)
下面是修改之后的Person实体类。
package com.songzihao.domain;
import java.io.Serial;
import java.io.Serializable;
public class Person implements Serializable {
//Java虚拟机看到实现Serializable接口之后,会自动生成一个序列化版本号
//假设这两个属性是昨天写好的
private String name;
private String sex;
private Integer age;
//今天,又添加一个hobby属性
//源代码改动之后,需要重新编译,进而生成全新的字节码文件
//并且Java虚拟机会再次生成一个新的序列化版本号
//此时,回到反序列化代码中,运行就会报错!!!
private String hobby;
public Person() {
}
public Person(String name, String sex) {
this.name = name;
this.sex = sex;
}
//getter and setter
//toString
}
序列化和反序列化操作的代码和上面的是一样的,这里不再给出代码,直接给出执行反序列化之后的运行结果。可以看到,代码运行报错了!!!
/**
* java.io.InvalidClassException:
* com.songzihao.domain.Person;
* local class incompatible:
* stream classdesc serialVersionUID = -2636134556316626889, (昨天的序列化版本号)
* local class serialVersionUID = -5103901396738868535 (今天的序列化版本号)
* 两次生成的序列化版本号不一致
*/
在这里,就要聊一聊Java中是通过什么来区分类的?
- 首先通过类名进行比对,如果类名不一样,肯定就不是同一个类。
- 如果类名一样,怎么办呢?这就需要用到——序列化版本号来区分!!!
也就是说,我昨天写的那个Person类,Java虚拟机给我生成了一个序列化版本号,此时我执行序列化和反序列化操作,完全可以将类文件内容通过对象输出流写入到硬盘中,也完全可以通过对象输入流从硬盘中读取到之前写入的内容。然而我今天修改Person类添加了一个属性,Java虚拟机又给我生成了一个序列化版本号,这两个序列化版本号是不一样的,也就是说这两个类虽然同名(但序列化版本号不一样,所以就不是同一个类),这个时候我再去执行反序列化操作,读取到的是今天新生成的这个序列化版本号,肯定就报错了啊,因为这并不是昨天的那个序列化版本号,内容一改变,自然就不一样了呗!!!
说白了,这种自动生成序列化版本号的方法有一个缺陷就是:代码不能修改!!!
5.2 手动添加序列化版本号
下面,我们来聊聊关于手动指定序列化版本号serialVersionUID:👇👇👇
serialVersionUID的取值是Java运行时环境根据类的内部细节自动生成的。如果对类的源代码作了修改,再重新编译,新生成的类文件的serialVersionUID的取值有可能也会发生变化。
每个类的serialVersionUID的默认值完全依赖于Java编译器的实现,对于同一个类,用不同的Java编译器编译,有可能会导致不同的 serialVersionUID,也有可能相同。
为了提高serialVersionUID的独立性和确定性,强烈建议在一个可序列化类中显示的定义serialVersionUID,为它赋予明确的值。
在下面的代码中,我们再次执行反序列化操作。
package com.songzihao.domain;
import java.io.Serial;
import java.io.Serializable;
/**
* 凡是一个类实现了Serializable接口,建议给该类提供一个固定不变的序列化版本号
* 这样,以后这个类即使代码修改了,但是序列化版本号不变,Java虚拟机会认为这是同一个类
*/
public class Person implements Serializable {
@Serial
private static final long serialVersionUID = -6374292363662261865L;
private String name;
private String sex;
private Integer age;
// private String hobby;
public Person() {
}
public Person(String name, String sex) {
this.name = name;
this.sex = sex;
}
//getter and setter
//toString
}
依次执行序列化和反序列化。可以看到代码正常执行。
在Person类中,添加一个hobby属性,再次执行反序列化操作。(因为上一步已经执行过序列化了)
package com.songzihao.domain;
import java.io.Serial;
import java.io.Serializable;
/**
* 凡是一个类实现了Serializable接口,建议给该类提供一个固定不变的序列化版本号
* 这样,以后这个类即使代码修改了,但是序列化版本号不变,Java虚拟机会认为这是同一个类
*/
public class Person implements Serializable {
@Serial
private static final long serialVersionUID = -6374292363662261865L;
private String name;
private String sex;
private Integer age;
private String hobby;
public Person() {
}
public Person(String name, String sex) {
this.name = name;
this.sex = sex;
}
//getter and setter
//toString
}
可以看到,代码仍然正确无误的执行。这就是手动指定序列化版本号的好处!!!即使代码修改也没任何问题,因为序列化版本号固定在此,类就是唯一的,无论何时我从硬盘中读取数据均可!!!