Java-序列化与反序列化

序言

把对象转换为字节序列的过程称为对象的序列化。

把字节序列恢复为对象的过程称为对象的反序列化。

对象的序列化主要有两种用途：
　　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

s​e​r​i​a​l​V​e​r​s​i​o​n​U​I​D​:​ ​字​面​意​思​上​是​序​列​化​的​版​本​号​，凡是实现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；如果删除了类的一些实例变量，可以兼容无需修改；如果给类增加了一些实例变量，可以兼容无需修改，只是反序列化后这些多出来的变量的值都是默认值。