1. 序列化的时候必须实现Serializable这个接口,基本类型的数据像Integer,String这些都实现了Serializable这个接口,实现序列化的时候有两种方式
a. 实现Serializable这个接口,如果有不需要序列化的属性使用transient修饰
b. 实现externalizable这个接口,复习里面的方法,根据需求去 实现要序列化和反序列化的字段和属性,externalizable是Serializable的子类;实现这个接口需要重写writeExternal和readExternal方法,指定对象序列化的属性和从序列化文件中读取对象属性的行为
c. 在用Serializable这个接口在实现序列化的时候,其父类必须要有个无参数的构造函数,否则反序列化就会报错;默认如果没有父类的话,自定义的类的类的父类为Object类;如下代码,反序列化时则会报错:
package Serializable;
import net.bytebuddy.implementation.bind.annotation.Super;
import java.io.*;
class Anninal {
private int type;
public Anninal(int type){
System.out.println("I will be Seriz in Anni");
}
}
public class Person extends Anninal implements Serializable {
private transient String name;
private int age;
//我不提供无参构造器
public Person(String name, int age) {
super(10);
System.out.println("I will be Person");
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
class WriteObject {
public static void main(String[] args) {
try (//创建一个ObjectOutputStream输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("abcd.txt"))) {
//将对象序列化到文件s
Person person = new Person("9龙", 23);
oos.writeObject(person);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class ReadObject {
public static void main(String[] args) {
try (//创建一个ObjectInputStream输入流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("abcd.txt"))) {
Person brady = (Person) ois.readObject();
System.out.println(brady);
} catch (Exception e) {
e.printStackTrace();
}
}
}
报错如下:
java.io.InvalidClassException: Serializable.Person; no valid constructor
at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150)
at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:768)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1775)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)
at Serializable.ReadObject.main(Person.java:57)
因为父类Anninal没有默认的构造函数,修改代码如下,则正确
package Serializable;
import net.bytebuddy.implementation.bind.annotation.Super;
import java.io.*;
//implements Serializable
class Anninal {
private int type;
public Anninal(int type){
System.out.println("I will be Seriz in Anni");
}
public Anninal(){
System.out.println("I will be Seriz in Anninal, I am a Default Constructor");
}
}
public class Person extends Anninal implements Serializable {
private transient String name;
private int age;
//我不提供无参构造器
public Person(String name, int age) {
super(10);
System.out.println("I will be Person");
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
class WriteObject {
public static void main(String[] args) {
try (//创建一个ObjectOutputStream输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("abcd.txt"))) {
//将对象序列化到文件s
Person person = new Person("9龙", 23);
oos.writeObject(person);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class ReadObject {
public static void main(String[] args) {
try (//创建一个ObjectInputStream输入流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("abcd.txt"))) {
Person brady = (Person) ois.readObject();
System.out.println(brady);
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果如下:
I will be Seriz in Anninal, I am a Default Constructor
Person{name='null', age=23}
如果父类实现Serializable,父类没有默认的够造函数也可以
package Serializable;
import net.bytebuddy.implementation.bind.annotation.Super;
import java.io.*;
class Anninal implements Serializable {
private int type;
public Anninal(int type){
System.out.println("I will be Seriz in Anni");
}
}
public class Person extends Anninal implements Serializable {
private transient String name;
private int age;
//我不提供无参构造器
public Person(String name, int age) {
super(10);
System.out.println("I will be Person");
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
class WriteObject {
public static void main(String[] args) {
try (//创建一个ObjectOutputStream输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("abcd.txt"))) {
//将对象序列化到文件s
Person person = new Person("9龙", 23);
oos.writeObject(person);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class ReadObject {
public static void main(String[] args) {
try (//创建一个ObjectInputStream输入流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("abcd.txt"))) {
Person brady = (Person) ois.readObject();
System.out.println(brady);
} catch (Exception e) {
e.printStackTrace();
}
}
}
这个则不会报错
private static final long serialVersionUID 的序列化版本号,只有版本号相同,即使更改了序列化属性,对象也可以正确被反序列化回来
如果反序列化使用的class的版本号与序列化时使用的不一致,反序列化会报InvalidClassException异常。
序列化版本号可自由指定,如果不指定,JVM会根据类信息自己计算一个版本号,这样随着class的升级,就无法正确反序列化;不指定版本号另一个明显隐患是,不利于jvm间的移植,可能class文件没有更改,但不同jvm可能计算的规则不一样,这样也会导致无法反序列化
什么情况下需要修改serialVersionUID呢?分三种情况。
- 如果只是修改了方法,反序列化不容影响,则无需修改版本号;
- 如果只是修改了静态变量,瞬态变量(transient修饰的变量),反序列化不受影响,无需修改版本号;
- 如果修改了非瞬态变量,则可能导致反序列化失败。如果新类中实例变量的类型与序列化时类的类型不一致,则会反序列化失败,这时候需要更改serialVersionUID。如果只是新增了实例变量,则反序列化回来新增的是默认值;如果减少了实例变量,反序列化时会忽略掉减少的实例变量
- 所有需要网络传输的对象都需要实现序列化接口,通过建议所有的javaBean都实现Serializable接口。
- 对象的类名、实例变量(包括基本类型,数组,对其他对象的引用)都会被序列化;方法、类变量、transient实例变量都不会被序列化。
- 如果想让某个变量不被序列化,使用transient修饰。
- 序列化对象的引用类型成员变量,也必须是可序列化的,否则,会报错。
- 反序列化时必须有序列化对象的class文件。
- 当通过文件、网络来读取序列化后的对象时,必须按照实际写入的顺序读取。
- 单例类序列化,需要重写readResolve()方法;否则会破坏单例原则。
- 同一对象序列化多次,只有第一次序列化为二进制流,以后都只是保存序列化编号,不会重复序列化。
- 建议所有可序列化的类加上serialVersionUID 版本号,方便项目升级。