黑马程序员_Java基础:序列化(Serializable)与反序列化
2015-07-31 23:31
561 查看
------- android培训、java培训、期待与您交流! ----------
在学习IO中的ObjectOutputStream和ObjectInputStream时,会涉及到序列化和反序列化的应用,那么它们是什么?
一、概念
序列化:把对象转换为字节序列的过程,叫做对象的序列化。
反序列化:把字节序列恢复为对象的过程,叫做对象的反序列化。
二、作用
主要有两种用途:
1.把对象的字节序列永久保存在硬盘中,也就是把内存中的数据(对象)持久化处理。
2.可以在网络上传输对象的字符序列,对象不再局限于本地使用。
无论那种用途,实际上都是为了保存在内存中的各种对象的状态(也就是实例变量,不是方法),并且可以把保存的对象状态再读出来。这是java提供的一种保存对象状态的机制。
三、应用
在开头有提到,在java.io包中有两个序列化对象的类,分别为:ObjectOutputStream将对象写入字节流,ObjectInputStream将字节流重构为对象。
需要注意的是,被序列化的对象必须要实现Serializable或者Externalizable接口。
1.例子一(Serializable基本使用方法):(为了方便阅读,下面例子中异常都做抛处理):
运行结果为:
有参数构造函数
序列化成功
反序列化成功
zhangsan:20
从结果可以看出,反序列化时,并没用通过Person类的构造函数,而是根据序列化的数据创建Person对象的。
要注意的是,默认serialVersionUID的取值是Java运行时,根据类的内部细节自动生成的。如果对类的源代码作了修改,再重新编译,新生成的类文件的serialVersionUID的取值有可能也会发生变化。类的serialVersionUID的默认值完全依赖于Java编译器的实现,对于同一个类,用不同的Java编译器编译,有可能会导致不同的 serialVersionUID,也有可能相同。为了提高serialVersionUID的独立性和确定性,强烈建议在一个可序列化类中显示的定义serialVersionUID,为它赋予明确的值。
显式定义serialVersionUID可以实现两种目的:
(1)若想不同版本的类(类有做过修改)序列化后,都能成功反序列化(兼容),就需要确保类的不同版本的类具有相同的serialVersionUID;
(2)若不想不同版本的类序列化后还能成功反序列化,就让不同版本的类具有不同的serialVersionUID。
2.例子二(被static和transient修饰成员无法按默认方式序列化):
先序列化:
后反序列化:
反序列化得到的结果是:
反序列化成功
zhangsan:20...0...0
以上可以看出被static和transient修饰的成员变量默认无法被序列化。(可看例子六自定义序列化)
3.例子三(父类的序列化):
运行结果为:
父类空参数构造函数
有参数构造函数
序列化成功
父类空参数构造函数
反序列化成功
zhangsan:20...0
从结果可以看出,反序列化后得到父类的heigh值,与序列化时的heigh值不一致。出现这个问题的原因是父类没有序列化,父类也需要实现Serializable接口。
同时我们也可以发现,反序列化时有调用父类的空参数构造函数。原因是在父类没有实现 Serializable 接口时,虚拟机是不会序列化父对象的,而一个 Java 对象的构造必须先有父对象,才有子对象,反序列化也不例外。所以反序列化时,为了构造父对象,只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时,它的值是调用父类无参构造函数后的值。如果考虑到这种序列化的情况,可以在父类无参构造函数中对变量进行初始化,否则的话,父类变量值都是默认声明的值,如 int 型的默认是 0,string 型的默认是 null。
所以如果父类没有序列化,可以通过父类的空参数构造函数初始化成员,即可保持对象序列化与反序列化数据的一致性。
另外还有一点需要注意,如果需要序列化的对象有调用其他对象,那么其他的对象也会被序列化。
4.例子四(序列化的存储规则):
运行结果为:
序列化成功99
序列化成功104
true
可以看到,第二次写入对象时文件只增加了 5 字节,并且反序列化后两个对象是相等的,这是为什么呢?
因为Java 序列化机制为了节省磁盘空间,具有特定的存储规则,当写入文件的为同一对象时,并不会再将对象的内容进行存储,而只是再次存储一份引用,上面增加的 5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时,恢复引用关系,使得 p1 和 p2 指向唯一的对象,二者相等,输出 true。该存储规则极大的节省了存储空间。
6.例子六(自定义序列化和反序列化):
运行结果:
zhangsan:0
以上例子实现了自定义序列化和反序列化的内容(name字段)。在序列化过程中,虚拟机会试图调用对象类里的 writeObject ()和 readObject() 方法,进行用户自定义的序列化和反序列化,如果没有这样的方法,则默认调用是 ObjectOutputStream 的 defaultWriteObject() 方法以及 ObjectInputStream() 的 defaultReadObject 方法。用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程,比如可以在序列化的过程中动态改变序列化的数值,这里不再列举例子。
另外要注意,使用writeObject ()和 readObject() 方法,可以序列化static和transient修饰的成员,从以下代码可以看出来:
7.例子七(Externalizable完全定制序列化):
运行结果:
调用无参数构造函数
zhangsan:0
可以看出,实现了Externalizable接口必须重写writeExternal()和readExternal方法,利用这些方法可以控制对象数据成员如何写入字节流。另外对象进行反序列化的时候,会先调用类的不带参数的构造函数,所以也要定义好空参数构造函数。
类实现 Externalizable时,头写入对象流中,然后类完全负责序列化和恢复数据成员,除了头以外,根本没有自动序列化。这里要注意,声明类实现 Externalizable接口会有重大的安全风险。writeExternal()与readExternal()方法声明为public,恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信息,则要格外小心。
在学习IO中的ObjectOutputStream和ObjectInputStream时,会涉及到序列化和反序列化的应用,那么它们是什么?
一、概念
序列化:把对象转换为字节序列的过程,叫做对象的序列化。
反序列化:把字节序列恢复为对象的过程,叫做对象的反序列化。
二、作用
主要有两种用途:
1.把对象的字节序列永久保存在硬盘中,也就是把内存中的数据(对象)持久化处理。
2.可以在网络上传输对象的字符序列,对象不再局限于本地使用。
无论那种用途,实际上都是为了保存在内存中的各种对象的状态(也就是实例变量,不是方法),并且可以把保存的对象状态再读出来。这是java提供的一种保存对象状态的机制。
三、应用
在开头有提到,在java.io包中有两个序列化对象的类,分别为:ObjectOutputStream将对象写入字节流,ObjectInputStream将字节流重构为对象。
需要注意的是,被序列化的对象必须要实现Serializable或者Externalizable接口。
1.例子一(Serializable基本使用方法):(为了方便阅读,下面例子中异常都做抛处理):
import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class Test { public static void main(String[] args) throws Exception{ Person p = new Person("zhangsan",20); serializePerson(p); Person p1 = deserializePerson(); System.out.println(p1); //结果打印zhangsan:20。 } // 序列化 private static void serializePerson(Object obj) throws Exception { ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(new File("c:\\obj.txt"))); out.writeObject(obj); System.out.println("序列化成功"); out.close(); } // 反序列化 private static Person deserializePerson() throws Exception { ObjectInputStream in = new ObjectInputStream(new FileInputStream("c:\\obj.txt")); Person p1 = (Person)in.readObject(); System.out.println("反序列化成功"); in.close(); return p1; } } class Person implements Serializable { // 注意,如果不指定serialVersionUID,序列化时会按默认方式进行,也会产生serialVersionUID。 // 但是如果后来有修改类中代码,序列化产生的serialVersionUID也会改变,这时反序列化就会失败,发生异常。 private static final long serialVersionUID = 1L; private String name; private int age; Person() { System.out.println("空参数构造函数"); } public Person(String name, int age) { System.out.println("有参数构造函数"); this.name = name; this.age = age; } public String toString() { return name+":"+age; } }
运行结果为:
有参数构造函数
序列化成功
反序列化成功
zhangsan:20
从结果可以看出,反序列化时,并没用通过Person类的构造函数,而是根据序列化的数据创建Person对象的。
要注意的是,默认serialVersionUID的取值是Java运行时,根据类的内部细节自动生成的。如果对类的源代码作了修改,再重新编译,新生成的类文件的serialVersionUID的取值有可能也会发生变化。类的serialVersionUID的默认值完全依赖于Java编译器的实现,对于同一个类,用不同的Java编译器编译,有可能会导致不同的 serialVersionUID,也有可能相同。为了提高serialVersionUID的独立性和确定性,强烈建议在一个可序列化类中显示的定义serialVersionUID,为它赋予明确的值。
显式定义serialVersionUID可以实现两种目的:
(1)若想不同版本的类(类有做过修改)序列化后,都能成功反序列化(兼容),就需要确保类的不同版本的类具有相同的serialVersionUID;
(2)若不想不同版本的类序列化后还能成功反序列化,就让不同版本的类具有不同的serialVersionUID。
2.例子二(被static和transient修饰成员无法按默认方式序列化):
先序列化:
public class TestSerialze { public static void main(String[] args) throws Exception{ Person p = new Person("zhangsan",20); serializePerson(p); } // 序列化 private static void serializePerson(Object obj) throws Exception { ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(new File("c:\\obj.txt"))); out.writeObject(obj); System.out.println("序列化成功"); out.close(); } } class Person implements Serializable { // 注意,如果不指定serialVersionUID,序列化时会按默认方式进行,也会产生serialVersionUID。 // 但是如果修改类中内容后,序列化产生新的serialVersionUID,跟原来不一样,这时反序列化就会失败,发生异常。 private static final long serialVersionUID = 1L; private String name; private int age; // 静态成员属于类,不能被序列化。 private static int count; // 瞬态也不能被序列化。 transient private int key; Person() { System.out.println("空参数构造函数"); } public Person(String name, int age) { System.out.println("有参数构造函数"); this.name = name; this.age = age; count++; key++; } public String toString() { return name+":"+age+"..."+count+"..."+key; } }
后反序列化:
import java.io.FileInputStream; import java.io.ObjectInputStream; public class TestDeserialze { public static void main(String[] args) throws Exception{ Object obj = deserializeObject(); System.out.println(obj); } private static Object deserializeObject() throws Exception { ObjectInputStream in = new ObjectInputStream(new FileInputStream("c:\\obj.txt")); Object obj = in.readObject(); System.out.println("反序列化成功"); in.close(); return obj; } }
反序列化得到的结果是:
反序列化成功
zhangsan:20...0...0
以上可以看出被static和transient修饰的成员变量默认无法被序列化。(可看例子六自定义序列化)
3.例子三(父类的序列化):
import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class Test { public static void main(String[] args) throws Exception{ Student p = new Student("zhangsan",20); serializeStudent(p); Student p1 = deserializeStudent(); System.out.println(p1); //打印结果为zhangsan:20...0。 } // 序列化 private static void serializeStudent(Object obj) throws Exception { ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(new File("c:\\obj.txt"))); out.writeObject(obj); System.out.println("序列化成功"); out.close(); } // 反序列化 private static Student deserializeStudent() throws Exception { ObjectInputStream in = new ObjectInputStream(new FileInputStream("c:\\obj.txt")); Student p1 = (Student)in.readObject(); System.out.println("反序列化成功"); in.close(); return p1; } } class Student extends Person implements Serializable { private static final long serialVersionUID = 1L; private String name; private int age; student() { System.out.println("空参数构造函数"); } public Student(String name, int age) { System.out.println("有参数构造函数"); this.name = name; this.age = age; } public String toString() { return name+":"+age+"..."+heigh; } } class Person { public int heigh; Person(){ System.out.println("父类空参数构造函数"); } void change(){ heigh = 5; } }
运行结果为:
父类空参数构造函数
有参数构造函数
序列化成功
父类空参数构造函数
反序列化成功
zhangsan:20...0
从结果可以看出,反序列化后得到父类的heigh值,与序列化时的heigh值不一致。出现这个问题的原因是父类没有序列化,父类也需要实现Serializable接口。
同时我们也可以发现,反序列化时有调用父类的空参数构造函数。原因是在父类没有实现 Serializable 接口时,虚拟机是不会序列化父对象的,而一个 Java 对象的构造必须先有父对象,才有子对象,反序列化也不例外。所以反序列化时,为了构造父对象,只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时,它的值是调用父类无参构造函数后的值。如果考虑到这种序列化的情况,可以在父类无参构造函数中对变量进行初始化,否则的话,父类变量值都是默认声明的值,如 int 型的默认是 0,string 型的默认是 null。
所以如果父类没有序列化,可以通过父类的空参数构造函数初始化成员,即可保持对象序列化与反序列化数据的一致性。
class Person { public int heigh; Person(){ System.out.println("父类空参数构造函数"); heigh = 5; //通过空参数构造函数来初始化成员变量。 } }
另外还有一点需要注意,如果需要序列化的对象有调用其他对象,那么其他的对象也会被序列化。
4.例子四(序列化的存储规则):
import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class Test { public static void main(String[] args) throws Exception{ Student p = new Student("zhangsan",20); serializeStudent(p); deserializeStudent(); } // 序列化 private static void serializeStudent(Object obj) throws Exception { File f = new File("c:\\obj.txt"); ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(f)); out.writeObject(obj); System.out.println("序列化成功"+f.length()); // 可以发现第两次序列化的文件大5字节。这是因为重复序列化同一对象时,不会再将对象的内容存储,而只是新增引用和一些控制信息。 out.writeObject(obj); System.out.println("序列化成功"+f.length()); out.close(); } // 反序列化 private static Student deserializeStudent() throws Exception { ObjectInputStream in = new ObjectInputStream(new FileInputStream("c:\\obj.txt")); Student p1 = (Student)in.readObject(); Student p2 = (Student)in.readObject(); // 结果为true,可以看出p1,p2都指向相同对象。 System.out.println(p1==p2); in.close(); return p1; } } class Student implements Serializable { private static final long serialVersionUID = 1L; private String name; private int age; public Student(String name, int age) { this.name = name; this.age = age; } public String toString() { return name+":"+age; } }
运行结果为:
序列化成功99
序列化成功104
true
可以看到,第二次写入对象时文件只增加了 5 字节,并且反序列化后两个对象是相等的,这是为什么呢?
因为Java 序列化机制为了节省磁盘空间,具有特定的存储规则,当写入文件的为同一对象时,并不会再将对象的内容进行存储,而只是再次存储一份引用,上面增加的 5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时,恢复引用关系,使得 p1 和 p2 指向唯一的对象,二者相等,输出 true。该存储规则极大的节省了存储空间。
6.例子六(自定义序列化和反序列化):
import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class Test { public static void main(String[] args) throws Exception{ Student p = new Student("zhangsan",20); serializeStudent(p); Student s = deserializeStudent(); System.out.println(s); //打印结果为zhangsan:0。 } private static void serializeStudent(Object obj) throws Exception { File f = new File("c:\\obj.txt"); ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(f)); out.writeObject(obj); out.close(); } private static Student deserializeStudent() throws Exception { ObjectInputStream in = new ObjectInputStream(new FileInputStream("c:\\obj.txt")); Student p1 = (Student)in.readObject(); in.close(); return p1; } } class Student implements Serializable { private static final long serialVersionUID = 1L; private String name; private int age; public Student(String name, int age) { this.name = name; this.age = age; } public String toString() { return name+":"+age; } // 自定义序列化,方法必须要私有才有效。 private void writeObject(ObjectOutputStream out) throws Exception { out.writeObject(name); } // 自定义反序列化,方法必须要私有才有效。 private void readObject(ObjectInputStream in) throws Exception { name = (String)in.readObject(); } }
运行结果:
zhangsan:0
以上例子实现了自定义序列化和反序列化的内容(name字段)。在序列化过程中,虚拟机会试图调用对象类里的 writeObject ()和 readObject() 方法,进行用户自定义的序列化和反序列化,如果没有这样的方法,则默认调用是 ObjectOutputStream 的 defaultWriteObject() 方法以及 ObjectInputStream() 的 defaultReadObject 方法。用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程,比如可以在序列化的过程中动态改变序列化的数值,这里不再列举例子。
另外要注意,使用writeObject ()和 readObject() 方法,可以序列化static和transient修饰的成员,从以下代码可以看出来:
import java.io.File; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class TestSerialize { public static void main(String[] args) throws Exception{ Person p = new Person("lisi",26); serializePerson(p); } private static void serializePerson(Object obj) throws Exception { ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(new File("c:\\obj.txt"))); out.writeObject(obj); out.close(); } } class Person implements Serializable { private static final long serialVersionUID = 1L; private static String name; private transient int age; Person() { System.out.println("Person空构造函数"); } public Person(String name, int age) { Person.name = name; this.age = age; } public String toString() { return name+":"+age; } // 必须是private修饰。 private void writeObject(ObjectOutputStream out) throws Exception{ // 要注意序列化的顺序。 out.writeObject(name); out.writeInt(age); } // 必须是private修饰。 private void readObject(ObjectInputStream in) throws Exception{ Person.name = (String)in.readObject(); age = (int)in.readInt(); } }
import java.io.FileInputStream; import java.io.ObjectInputStream; public class TestDeserialze { public static void main(String[] args) throws Exception{ deserializeObject(); } private static void deserializeObject() throws Exception { ObjectInputStream in = new ObjectInputStream(new FileInputStream("c:\\obj.txt")); Object obj = in.readObject(); in.close(); System.out.println(obj); //打印结果:lisi:26 } }
7.例子七(Externalizable完全定制序列化):
import java.io.Externalizable; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectInputStream; import java.io.ObjectOutput; import java.io.ObjectOutputStream; public class Test { public static void main(String[] args) throws Exception{ Student p = new Student("zhangsan",20); serializeStudent(p); Student s = deserializeStudent(); System.out.println(s); //打印结果为zhangsan:0。 } private static void serializeStudent(Object obj) throws Exception { File f = new File("c:\\obj.txt"); ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(f)); out.writeObject(obj); out.close(); } private static Student deserializeStudent() throws Exception { ObjectInputStream in = new ObjectInputStream(new FileInputStream("c:\\obj.txt")); Student p1 = (Student)in.readObject(); in.close(); return p1; } } class Student implements Externalizable { private static final long serialVersionUID = 1L; private String name; private int age; // 因为实现Externalizable,必须定义空构造函数,而且权限必须要public。否则发生异常InvalidClassException。 public Student() { System.out.println("调用无参数构造函数"); } Student(String name, int age) { this.name = name; this.age = age; } public String toString() { return name+":"+age; } // 自定义序列化。 public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(name); } // 自定义反序列化。 public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { name = (String)in.readObject(); } }
运行结果:
调用无参数构造函数
zhangsan:0
可以看出,实现了Externalizable接口必须重写writeExternal()和readExternal方法,利用这些方法可以控制对象数据成员如何写入字节流。另外对象进行反序列化的时候,会先调用类的不带参数的构造函数,所以也要定义好空参数构造函数。
类实现 Externalizable时,头写入对象流中,然后类完全负责序列化和恢复数据成员,除了头以外,根本没有自动序列化。这里要注意,声明类实现 Externalizable接口会有重大的安全风险。writeExternal()与readExternal()方法声明为public,恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信息,则要格外小心。
相关文章推荐
- 面试题37_两个链表的第一个公共结点
- php5.3以后各版本的特性(主要是整理一下面试用的)
- 黑马程序员——IO流(一)
- 黑马程序员——反射
- 阿里算法工程师内推面试经历
- 面试之jsp、Servlet相关知识——生命周期, 区别等
- 黑马程序员——走进面向对象
- 黑马程序员---iOS基础---面向对象编程思想
- 学习与职业规划——机器学习的学习路径和职业规划(简单版)
- 工作小记(一)----面试总结
- 黑马程序员------OC ARC管理和Category
- 黑马程序员——String类
- (剑指Offer)面试题52:构建乘积数组
- 面试准备---Java异常
- 剑指offer面试题36数组中的逆序对数
- 剑指Offer面试题13(java版):在O(1)时间删除链表节点
- 互联网公司机器学习数据挖掘类的职位面试主要考察哪些?
- 面试准备--JAVA集合框架
- (剑指Offer)面试题51:数组中重复的数字
- 数据挖掘工程师面试指南