序言
把对象转换为字节序列的过程称为对象的序列化。
把字节序列恢复为对象的过程称为对象的反序列化。
对象的序列化主要有两种用途:
1)把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中(持久化对象);
2)在网络上传送对象的字节序列(网络传输对象)。
简而言之,Java对象是在JVM中生成的,如果需要远程传输或保存到硬盘上,就需要将Java对象转换成可传输的文件流。
在很多应用中,需要对某些对象进行序列化,让它们离开内存空间,入住物理硬盘,以便长期保存。比如最常见的是Web服务器中的Session对象,当有 10万用户并发访问,就有可能出现10万个Session对象,内存可能吃不消,于是Web容器就会把一些seesion先序列化到硬盘中,等要用了,再把保存在硬盘中的对象还原到内存中。
当两个进程在进行远程通信时,彼此可以发送各种类型的数据。无论是何种类型的数据,都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再恢复为Java对象。
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()方法读取对象。
对象序列化和反序列范例
定义一个Person类,实现Serializable接口:
public class Person implements Serializable {
private String name = null;
private Integer age = null;
public Person(){
System.out.println("无参构造");
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
//getter setter方法省略...
@Override
public String toString() {
return "[" + name + ", " + age+"]";
}
}
MySerilizable 是一个简单的序列化程序,它先将一个Person对象保存到文件person.txt中,然后再从该文件中读出被存储的Person对象,并打印该对象。
public class MySerilizable {
public static void main(String[] args) throws Exception {
File file = new File("person.txt");
//序列化持久化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
Person person = new Person("Peter", 27);
out.writeObject(person);
out.close();
//反序列化,并得到对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
Object newPerson = in.readObject(); // 没有强制转换到Person类型
in.close();
System.out.println(newPerson);
}
}
输出结果:
[Peter, 27]
结果没有打印“无参构造”,说明反序列化机制无需通过构造器来初始Java对象。
选择序列化
1、transient
当对某个对象进行序列化时,系统会自动将该对象的所有属性依次进行序列化,如果某个属性引用到别一个对象,则被引用的对象也会被序列化。如果被引用的对象的属性也引用了其他对象,则被引用的对象也会被序列化。 这就是递归序列化。
有时候,我们并不希望出现递归序列化,或是某个存敏感信息(如银行密码)的属性不被序列化,我们就可通过transient关键字修饰该属性来阻止被序列化。
将上面的Person类的age属性用transient修饰:
transient private Integer age = null;
再去执行MySerilizable的结果为:
[Peter, null] //返序列化时没有值,说明age字段未被序列化
2、writeObject()与readObject()
使用transient关键字阻止序列化虽然简单方便,但被它修饰的属性被完全隔离在序列化机制之外,导致了在反序列化时无法获取该属性的值,而通过在需要序列化的对象的Java类里加入writeObject()方法与readObject()方法可以控制如何序列化各属性,甚至完全不序列化某些属性(此时就transient一样)。
如果我们想要上面的Person类里的name属性在序列化后存在文件里不让别人知道具体是什么(加密),我们就可在Person类里加如下代码:
//自定义序列化
private void writeObject(ObjectOutputStream out) throws IOException {
// out.defaultWriteObject(); // 将当前类的非静态和非瞬态字段写入此流。
//如果不写,如果还有其他字段,则不会被序列化
out.writeObject(new StringBuffer(name).reverse());
//将name简单加密(反转),这样别人就知道是怎么回事,当然实际应用不可能这样加密。
out.writeInt(age);
}
//反序列化
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
//in.defaultReadObject();// 从此流读取当前类的非静态和非瞬态字段。
//如果不写,其他字段就不能被反序列化
name = ((StringBuffer)in.readObject()).reverse().toString(); //解密
age = in.readInt();
}
详细的自定义序列化与反序列化可参见ObjectOutputStream 和ObjectInputStream 类的JDK文档。
Externalizable接口
只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自Serializable接口,实现Externalizable接口的类完全由自身来控制序列化的行为,而仅实现Serializable接口的类可以采用默认的序列化方式 。
所以说Externalizable接口 与Serializable 接口类似,只是Externalizable接口需要强制自定义序列化。
要序列化对象的代码:
public class Teacher implements Externalizable{
private String name;
private Integer age;
public Teacher(){
System.out.println("无参构造");
}
public Teacher(String name,Integer age){
System.out.println("有参构造");
this.name = name;
this.age = age;
}
//setter、getter方法省略
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(new StringBuffer(name).reverse()); //将name简单加密
//out.writeInt(age); //注掉这句后,age属性将不能被序化
}
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
name = ((StringBuffer) in.readObject()).reverse().toString();
//age = in.readInt();
}
@Override
public String toString() {
return "[" + name + ", " + age+ "]";
}
}
主函数代码改为:
public class MySerilizable {
public static void main(String[] args) throws Exception {
File file = new File("person.txt");
//序列化持久化对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
Teacher person = new Teacher("Peter", 27);
out.writeObject(person);
out.close();
//反序列化,并得到对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
Object newPerson = in.readObject(); // 没有强制转换到Person类型
in.close();
System.out.println(newPerson);
}
}
打印结果:
有参构造
无参构造 //与Serializable 不同的是,还调用了无参构造
[Peter, null] //age未被序列化,所以未取到值
版本 serialVersionUID
serialVersionUID: 字面意思上是序列化的版本号,凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量!!!!
实现Serializable接口的类如果类中没有添加serialVersionUID,那么就会出现如下的警告提示
用鼠标点击就会弹出生成serialVersionUID的对话框,如下图所示:
serialVersionUID有两种生成方式:
(1)采用“+Add default serial version ID”这种方式生成的serialVersionUID是1L:
private static final long serialVersionUID = 1L;
(2)采用“+Add generated serial version ID”这种方式生成的serialVersionUID是根据类名,接口名,方法和属性等来生成的,例如:
private static final long serialVersionUID = 4603642343377807741L;
扯了那么多,那么serialVersionUID(序列化版本号)到底有什么用呢,我们用如下的例子来说明一下serialVersionUID的作用,看下面的代码:
/**
* Customer实现了Serializable接口,可以被序列化
*/
class Customer implements Serializable {
//Customer类中没有定义serialVersionUID
private String name;
private int age;
public Customer(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 重写Object类的toString()方法
* @return string
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "name=" + name + ", age=" + age;
}
}
public class TestSerialversionUID {
public static void main(String[] args) throws Exception {
SerializeCustomer();// 序列化Customer对象
Customer customer = DeserializeCustomer();// 反序列Customer对象
System.out.println(customer);
}
/**
* Description: 序列化Customer对象
*/
private static void SerializeCustomer() throws FileNotFoundException,
IOException {
Customer customer = new Customer("gacl",25);
// ObjectOutputStream 对象输出流
ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(
new File("E:/Customer.txt")));
oo.writeObject(customer);
System.out.println("Customer对象序列化成功!");
oo.close();
}
/**
* Description: 反序列Customer对象
*/
private static Customer DeserializeCustomer() throws Exception, IOException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
new File("E:/Customer.txt")));
Customer customer = (Customer) ois.readObject();
System.out.println("Customer对象反序列化成功!");
return customer;
}
}
运行结果:
序列化和反序列化都成功了。
下面我们修改一下Customer类,添加多一个sex属性,如下:
class Customer implements Serializable {
//Customer类中没有定义serialVersionUID
private String name;
private int age;
//新添加的sex属性
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;
}
/*
* @Description 重写Object类的toString()方法
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "name=" + name + ", age=" + age;
}
}
然后执行反序列操作,此时就会抛出如下的异常信息:
Exception in thread "main" java.io.InvalidClassException: Customer;
local class incompatible:
stream classdesc serialVersionUID = -88175599799432325,
local class serialVersionUID = -5182532647273106745
意思就是说,文件流中的class和classpath中的class,也就是修改过后的class,不兼容了,处于安全机制考虑,程序抛出了错误,并且拒绝载入。
那么如果我们真的有需求要在序列化后添加一个字段或者方法呢?应该怎么办?那就是自己去指定serialVersionUID。在TestSerialversionUID例子中,没有指定Customer类的serialVersionUID的,那么java编译器会自动给这个class进行一个摘要算法,类似于指纹算法,只要这个文件多一个空格,得到的UID就会截然不同的,可以保证在这么多类中,这个编号是唯一的。
所以,添加了一个字段后,由于没有显指定 serialVersionUID,编译器又为我们生成了一个UID,当然和前面保存在文件中的那个不会一样了,于是就出现了2个序列化版本号不一致的错误。因此,只要我们自己指定了serialVersionUID,就可以在序列化后,去添加一个字段,或者方法,而不会影响到后期的还原,还原后的对象照样可以使用,而且还多了方法或者属性可以用。
下面继续修改Customer类,给Customer指定一个serialVersionUID,修改后的代码如下:
class Customer implements Serializable {
/**
* Customer类中定义的serialVersionUID(序列化版本号)
*/
private static final long serialVersionUID = -5182532647273106745L;
private String name;
private int age;
//新添加的sex属性
//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;
}*/
/**
* @Description 重写Object类的toString()方法
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "name=" + name + ", age=" + age;
}
}
重新执行序列化操作,将Customer对象序列化到本地硬盘的Customer.txt文件存储,然后修改Customer类,添加sex属性,修改后的Customer类代码如下:
class Customer implements Serializable {
/**
* Customer类中定义的serialVersionUID(序列化版本号)
*/
private static final long serialVersionUID = -5182532647273106745L;
private String name;
private int age;
//新添加的sex属性
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;
}
/**
* @Description 重写Object类的toString()方法
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "name=" + name + ", age=" + age;
}
}
执行反序列操作,这次就可以反序列成功了,如下所示:
总结
由于反序列化Java对象的时候,必须提供该对象的class文件,但是随着项目的升级class文件文件也会升级,Java如何保证兼容性呢?答案就是 serialVersionUID。每个可以序列化的类里面都会存在一个serialVersionUID,只要这个值前后一致,即使类升级了,系统仍然会认为他们是同一版本如果serialVersionUID没有显式生成,系统就会自动生成一个默认值。
public class Student implements Serializable {
private static final long serialVersionUID=1L;
...
}
此时,如果在序列化后我们将该类作添加或减少一个字段等的操作,系统在反序列化时会重新生成一个serialVersionUID然后去和已经序列化的对象进行比较,就会报序列号版本不一致的错误。为了避免这种问题,一般系统都会要求我们实现serialiable接口的时候在类中显式地声明一个serialVersionUID。
所以,显式定义serialVersionUID有如下两种用途:
1、希望类的不同版本对序列化兼容时,需要确保类的不同版本具有相同的serialVersionUID;
2、不希望类的不同版本对序列化兼容时,需要确保类的不同版本具有不同的serialVersionUID。
那么我们如何维护这个版本号呢?
(1)只修改了类的方法,无需改变serialVersionUID;
(2)只修改了类的static变量和使用transient修饰的实例变量,无需改变serialVersionUID;
(3)如果修改了实例变量的类型,例如一个变量原来是int改成了String,则反序列化会失败,需要修改serialVersionUID;如果删除了类的一些实例变量,可以兼容无需修改;如果给类增加了一些实例变量,可以兼容无需修改,只是反序列化后这些多出来的变量的值都是默认值。