1.概念
- 把对象转换为字节序列的过程称为对象的序列化。
- 把字节序列恢复为对象的过程称为对象的反序列化。
对象的序列化主要有两种用途:
- 把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中;
- 在网络上传送对象的字节序列。
在很多应用中,需要对某些对象进行序列化,让它们离开内存空间,入住物理硬盘,以便长期保存。比如最常见的是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接口的类可以 采用默认的序列化方式 。
对象序列化包括如下步骤:
- 创建一个对象输出流,它可以包装一个其他类型的目标输出流,如文件输出流;
- 通过对象输出流的writeObject()方法写对象。
对象反序列化的步骤如下:
- 创建一个对象输入流,它可以包装一个其他类型的源输入流,如文件输入流;
- 通过对象输入流的readObject()方法读取对象。
举例:
public class Person implements Serializable {
private static final long serialVersionUID = -8716807197529864217L;
private String name;
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Test {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//序列化person对象
SerializePerson();
//反序列化文件数据到person对象中
Person person = deSerializePerson();
System.out.println(person);
}
//序列化方法
public static void SerializePerson() throws IOException {
Person person = new Person();
person.setName("小明");
person.setAge(20);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("c://test//se.txt")));
objectOutputStream.writeObject(person);
System.out.println("Person对象序列化成功!");
objectOutputStream.close();
}
//反序列化方法
public static Person deSerializePerson() throws IOException, ClassNotFoundException {
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("c://test//se.txt")));
Person person = (Person)objectInputStream.readObject();
System.out.println("Person对象反序列化成功!");
return person;
}
}
序列化Person成功后C盘生成了一个se.txt文件,而反序列化Person是读取E盘的se.txt后生成了一个Person对象
3. serialVersionUID的作用
serialVersionUID:字面意思上是序列化的版本号,凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量。这种方式生成的serialVersionUID是根据类名,接口名,方法和属性等来生成的,例如:
private static final long serialVersionUID = -8716807197529864217L;
举例:
public class TestSerialversionUID {
public static void main(String[] args) throws IOException, ClassNotFoundException {
serializeCustomer();
Customer customer = DeSerializeCustomer();
System.out.println(customer);
}
//customer 序列化方法
public static void serializeCustomer() throws IOException {
Customer customer = new Customer("李明",20);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("c://test//customer.txt")));
objectOutputStream.writeObject(customer);
objectOutputStream.close();
System.out.println("Customer序列化成功!");
}
//customer 反序列方法
public static Customer DeSerializeCustomer() throws IOException, ClassNotFoundException {
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("c://test//customer.txt")));
Customer customer = (Customer)objectInputStream.readObject();
System.out.println("Customer反序列化成功!");
return customer;
}
}
public class Customer implements Serializable {
//Customer 中没有定义serialVersionUID
private String name;
private int age;
public Customer(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Customer{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
以上我们第一次测试,对象可以顺利地序列化和反序列化。
Customer序列化成功!
Customer反序列化成功!
Customer{name='李明', age=20}
下面修改一下Customer类,添加一个属性 sex
public class Customer implements Serializable {
private String name;
private int age;
private String sex; //新增的一个属性
public Customer(String name, int age) {
this.name = name;
this.age = age;
}
public Customer(String name, int age,String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
@Override
public String toString() {
return "Customer{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
再次运行test的程序中的反序列化方法(此时,只运行反序列化方法,用之前2个属性的文件来反序列化到内存中的3个属性)
报错:
Exception in thread "main" java.io.InvalidClassException: com.gs.test.objser.Customer; local class incompatible: stream classdesc serialVersionUID = 3632770865303553024, local class serialVersionUID = 1255731269111680396
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:616)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1843)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1713)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2000)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1535)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:422)
at com.gs.test.objser.TestSerialversionUID.DeSerializeCustomer(TestSerialversionUID.java:25)
at com.gs.test.objser.TestSerialversionUID.main(TestSerialversionUID.java:8)
意思就是说,文件流中的class和classpath中的class,也就是修改过后的class,不兼容了,处于安全机制考虑,程序抛出了错误,并且拒绝载入。那么如果我们真的有需求要在序列化后添加一个字段或者方法呢?应该怎么办?那就是自己去指定serialVersionUID。在TestSerialversionUID例子中,没有指定Customer类的serialVersionUID的,那么java编译器会自动给这个class进行一个摘要算法,类似于指纹算法,只要这个文件
多一个空格,得到的UID就会截然不同的,可以保证在这么多类中,这个编号是唯一的。所以,添加了一个字段后,由于没有显指定
serialVersionUID,编译器又为我们生成了一个UID,当然和前面保存在文件中的那个不会一样了,于是就出现了2个序列化版本号不一致的错误。因此,只要我们自己指定了serialVersionUID,就可以在序列化后,去添加一个字段,或者方法,而不会影响到后期的还原,还原后的对象照样可以使用,而且还多了方法或者属性可以用。
下面继续修改Customer类,给Customer指定一个serialVersionUID,修改后的代码如下:
public class Customer implements Serializable {
private static final long serialVersionUID = 1255731269111680396L; //新增
private String name;
private int age;
private String sex;
private String addr;
public Customer(String name, int age) {
this.name = name;
this.age = age;
}
public Customer(String name, int age, String sex,String addr) {
this.name = name;
this.age = age;
this.sex = sex;
this.addr = addr;
}
@Override
public String toString() {
return "Customer{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
", addr='" + addr + '\'' +
'}';
}
}
再次重复以上过程,发现,问题消失了,可以正确序列化和反序列化