黑马程序员_Java基础：序列化（Serializable）与反序列化

　　------- android培训、java培训、期待与您交流！ ----------

在学习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，恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信息，则要格外小心。