Java对象序列化和反序列化

Java对象序列化和反序列化

在Java中，我们如果要保存一个对象的瞬时状态值，以便在下次使用时能够得到这些值，或者持久化对象，或者使用RMI(远程方法调用)，或在网络中传递对象时，此时我们就需要将对象序列化，实现序列化，我们只要实现Serializable接口，该接口是一个标记接口（Tag interface），即里面没有方法，其主要作用就是告诉JVM该类的对象可以进行序列化。

一般来说，很多类的对象都实现了Serializable接口，但是，有些对象是不能进行序列化的，比如与数据库相关的连接对象，file对象等等，保存这些对象的状态值是没有意义的，因此Object并没有实现Serializable接口也是这个原因，若想要将对象序列化，我们只要实现Serializable接口即可，一个类的父类实现了Serializable接口，则其子类默认也会实现该接口，反过来，若其子类需要序列化，则其父类不一定要实现Serializable接口。

package test2;

/**
 * Created by siege on 2015-09-05.
 */
public class Creature {
    public Creature() {
        System.out.println("Creature");
    }
}

---

package test2;


/**
 * Created by siege on 2015-09-05.
 */
public class Person extends Creature {
    private String name;
    private int age;
    private String sex;

    public Person(String name, int age, String sex) {
        System.out.println("Person父类有参构造器,"+"name:"+name+",age:"+age+",sex:"+sex);
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public Person() {
        System.out.println("Person父类无参构造器");
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getSex() {
        return sex;
    }
}

---

package test2;

import java.io.Serializable;

/**
 * Created by siege on 2015-09-05.
 */
public class Student extends Person implements Serializable {
    private float score;
    private int grade;

    public Student(float score, int grade) {
        super("siege", 25, "male");
        System.out.println("Student子类构造器,"+"score:"+score+",grade:"+grade);
        this.score = score;
        this.grade = grade;
    }

    public float getScore() {
        return score;
    }

    public int getGrade() {
        return grade;
    }
}

---

package test2;

import java.io.*;

/**
 * Created by siege on 2015-09-05.
 */
public class TestSerivalizable {
    public static void main(String[] args) {
        FileOutputStream fos;
        ObjectOutputStream oos;
        Student student=new Student(78f,2);
        try {
            fos=new FileOutputStream("C:\\test\\student.out");
            oos=new ObjectOutputStream(fos);
            oos.writeObject(student);

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

---

package test2;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/**
 * Created by siege on 2015-09-05.
 */
public class TestSerivalizable1 {
    public static void main(String[] args) {

           FileInputStream fio;
           ObjectInputStream ois;
        try {
            fio = new FileInputStream("C:\\test\\student.out");
            ois = new ObjectInputStream(fio);
            Student s = (Student) ois.readObject();
            System.out.println("name:"+s.getName()+",age:"+s.getAge()+",sex:"+s.getSex()
                            +",score:"+s.getScore()+",grade:"+s.getGrade()
            );
        }catch (Exception e){
            e.printStackTrace();
        }



    }
}

---

在序列化Student时，其打印结果如下：

Creature
Person父类有参构造器,name:siege,age:25,sex:male
Student子类构造器,score:78.0,grade:2

由于Person类没有实现Serializable接口，故在反序列化时调用了其无参构造器，同时调用了其父类Creature的构造器进行了初始化，导致其Persond对象中的状态信息丢失：

Creature
Person父类无参构造器
name:null,age:0,sex:null,score:78.0,grade:2

若Person类实现了Serializable接口，则结果如下：

Creature
name:siege,age:25,sex:male,score:78.0,grade:2

此时只调用了未实现Serializable接口的Creature构造器。同时信息未丢失。

序列化是为了保存对象的状态，因此，static类型的变量不会被序列化，因为保存其值是没有意义的，它会在运行过程中动态变化的，对于引用类型的变量，或者其引用变量中又包含引用变量，我们在序列化该对象时，都对其进行了序列化，我们只要确保他们都实现了Serializable接口。

在序列化的过程中，如果对于有些变量，我们不希望保存其值，那么我们在该引用变量或者原始变量名前加上关键字transient即可，这样，该字段就不会被序列化了，在反序列化恢复成对象时，其默认值为null（字段为对象类型）或者原始类型的默认值（原始类型变量）。

在反序列化时，JVM将序列化的对象进行重新组装，然后在heap中开辟空间，生成相应类型的对象，在该过程中，其并不调用构造器（因为调用构造器则将其值进行了初始化，而不是我们保存时的状态了）。但是，如果父类没有实现Serializable，子类实现了Serializable接口，则在反序列化时会调用父类即其父类以上的构造器。当然，我们我们如果不想使用java提供的默认的序列化方式，我们只要实现Externalizable接口即可，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。用该接口时，序列化的细节需要由程序员去完成。

举例如下：

package com.test;

import java.io.Serializable;

/**
 * Created by siege on 2015-07-28.
 */
public class Person implements Serializable {

    private transient  int num=3;
    private transient  String description="hello";
    private static  int count;
    private String name;
    private int age;

    public Person(String name, int age) {
        count++;
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "name"+":"+name+",age:"+age+",count:"+count+",num:"+num+",description:"+description;
    }
}

package com.test;

import java.io.*;

/**
 * Created by siege  on 2015-07-28.
 */
public class SerializableTest {

    public static void main(String[] args) {
        Person person1=new Person("siege1",20);
        Person person2=new Person("siege2",21);
        Person person3=new Person("siege3",22);
        try {
            FileOutputStream fos=new FileOutputStream("C:\\test\\person.out");
            ObjectOutputStream objectOutputStream=new ObjectOutputStream(fos);
            objectOutputStream.writeObject(person1);
            objectOutputStream.writeObject(person2);
            objectOutputStream.writeObject(person3);
            objectOutputStream.close();
        } catch (java.io.IOException e) {
            e.printStackTrace();
        }

        try {
            FileInputStream fin=new FileInputStream("C:\\test\\person.out");
            ObjectInputStream objectInputStream=new ObjectInputStream(fin);
            try {
                Person p1=(Person)objectInputStream.readObject();
                Person p2=(Person)objectInputStream.readObject();
                Person p3=(Person)objectInputStream.readObject();
                System.out.println(p1);
                System.out.println(p2);
                System.out.println(p3);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

输出结果如下：

name:siege1,age:20,count:3,num:0,description:null
name:siege2,age:21,count:3,num:0,description:null
name:siege3,age:22,count:3,num:0,description:null

由此可见，static变量的值是在我们反序列化之后再从类变量中取出放入对象中的，同时，transient类型的变量没有序列化，反序列化的值为默认值。

若Person没有实现Serializable接口，则会出现

java.io.NotSerializableException

错误。

如果我们在序列化对象之后，将该对象对应的类做了改动，则在反序列化时可能出现异常（java.io.InvalidClassException），原因是JVM在序列化对象时会在序列化对象上和其类上生成一个同一个serialVersionUID，在反序列化时，会比较该值，如果相同，则可以序列化，否则出现异常。