Java對象的序列化與反序列化

序列化的含義和意義

對象序列化的目標是將對象保存到磁盤中，或允許在網絡中直接傳輸對象。對象序列化機制允許把內存中的Java對象轉換成平台無關的二進制流，從而允許把這種二進制流持久地保存在磁盤上，通過網絡將這種二進制流傳輸到另一個網絡節點。其他程序一旦獲得了這種二進制流，都可以將這種二進制流恢復成原來的Java對象。 

對象序列化機制（object serialization）是Java語言內建的一種對象持久化方式，通過對象序列化，可以把對象保存為字節數組，這些字節數組可以保存在磁盤上，或通過網絡傳輸。在有需要的時候將這個字節數組通過反序列化的方式再轉換成對象。對象序列化可以很容易的在JVM中的活動對象和字節數組（流）之間進行轉換。

在Java中，對象的序列化與反序列化被廣泛應用到RMI(遠程方法調用)及網絡傳輸中。通常建議：程序創建的每個JavaBean類都實現Serializable。

相關接口及類

Java為了方便開發人員將Java對象進行序列化及反序列化提供了一套方便的API來支持。其中包括以下接口和類：

java.io.Serializable

java.io.Externalizable

ObjectOutput

ObjectInput

ObjectOutputStream

ObjectInputStream

Serializable 接口

類通過實現 java.io.Serializable 接口以啟用其序列化功能。未實現此接口的類將無法使其任何狀態序列化或反序列化。可序列化類的所有子類型本身都是可序列化的。序列化接口沒有方法或字段，僅用於標識可序列化的語義。

當試圖對一個對象進行序列化的時候，如果遇到不支持 Serializable 接口的對象。在此情況下，將拋出 NotSerializableException。

如果要序列化的類有父類，要想同時將在父類中定義過的變量持久化下來，那么父類也應該集成java.io.Serializable接口。

下面是一個實現了java.io.Serializable接口的類

package com.hollischaung.serialization.SerializableDemos;
import java.io.Serializable;
/**
 * Created by hollis on 16/2/17.
 * 實現Serializable接口
 */
public class User1 implements Serializable {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
} 

通過下面的代碼進行序列化及反序列化

package com.hollischaung.serialization.SerializableDemos;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;

import java.io.*;
/**
 * Created by hollis on 16/2/17.
 * SerializableDemo1 結合SerializableDemo2說明 一個類要想被序列化必須實現Serializable接口
 */
public class SerializableDemo1 {

    public static void main(String[] args) {
        //Initializes The Object
        User1 user = new User1();
        user.setName("hollis");
        user.setAge(23);
        System.out.println(user);

        //Write Obj to File
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
            oos.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            IOUtils.closeQuietly(oos);
        }

        //Read Obj from File
        File file = new File("tempFile");
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream(file));
            User1 newUser = (User1) ois.readObject();
            System.out.println(newUser);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            IOUtils.closeQuietly(ois);try{FileUtils.forceDelete(file);}catch(IOException e){
                e.printStackTrace();}}}}//OutPut://User{name='hollis', age=23}//User{name='hollis', age=23}

使用對象流實現序列化

反序列化機制無須通過構造器來初始化Java對象。

如果使用序列化機制向文件中寫入多個Java對象，使用反序列化機制恢復對象時必須按實際寫入的順序讀取。

當一個可序列化類有多個父類時（包括直接父類和間接父類），這些父類要么有無參數的構造器，要么也是可序列化的——否則反序列化時將拋出InvalidClassException異常。如果父類是不可序列化的，只是帶有無參數的構造器，則該父類中定義的Field值不會序列化到二進制流中。

對象引用的序列化

當程序序列化一個Teacher對象時，如果該Teacher對象持有一個Person對象的引用，為了在反序列化時可以正常恢復該Teacher對象，程序會順帶將該Person對象也進行序列化，所以Person類也必須是可序列化的，否則Teacher類將不可序列化。

當使用Java序列化機制序列化可變對象時一定要注意，只有第一次調用writeObject()方法來輸出對象時才會將對象轉換成字節序列，並寫入到ObjectOutputStream；在后面程序中即使該對象的Field發生了改變，再次調用writeObject()方法輸出該對象時，改變后的Field也不會被輸出。

Externalizable接口

除了Serializable 之外，java中還提供了另一個序列化接口Externalizable

為了了解Externalizable接口和Serializable接口的區別，先來看代碼，我們把上面的代碼改成使用Externalizable的形式。

package com.hollischaung.serialization.ExternalizableDemos;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

/**
 * Created by hollis on 16/2/17.
 * 實現Externalizable接口
 */
public class User1 implements Externalizable {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void writeExternal(ObjectOutput out) throws IOException {

    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {

    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
} 

package com.hollischaung.serialization.ExternalizableDemos;

import java.io.*;

/**
 * Created by hollis on 16/2/17.
 */
public class ExternalizableDemo1 {

    //為了便於理解和節省篇幅，忽略關閉流操作及刪除文件操作。真正編碼時千萬不要忘記
    //IOException直接拋出
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //Write Obj to file
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
        User1 user = new User1();
        user.setName("hollis");
        user.setAge(23);
        oos.writeObject(user);
        //Read Obj from file
        File file = new File("tempFile");
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        User1 newInstance = (User1) ois.readObject();
        //output
        System.out.println(newInstance);
    }
}
//OutPut:
//User{name='null', age=0} 

通過上面的實例可以發現，對User1類進行序列化及反序列化之后得到的對象的所有屬性的值都變成了默認值。也就是說，之前的那個對象的狀態並沒有被持久化下來。這就是Externalizable接口和Serializable接口的區別：

Externalizable繼承了Serializable，該接口中定義了兩個抽象方法：writeExternal()與readExternal()。當使用Externalizable接口來進行序列化與反序列化的時候需要開發人員重寫writeExternal()與readExternal()方法。由於上面的代碼中，並沒有在這兩個方法中定義序列化實現細節，所以輸出的內容為空。還有一點值得注意：在使用Externalizable進行序列化的時候，在讀取對象時，會調用被序列化類的無參構造器去創建一個新的對象，然后再將被保存對象的字段的值分別填充到新對象中。所以，實現Externalizable接口的類必須要提供一個public的無參的構造器。

按照要求修改之后代碼如下：

package com.hollischaung.serialization.ExternalizableDemos;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

/**
 * Created by hollis on 16/2/17.
 * 實現Externalizable接口,並實現writeExternal和readExternal方法
 */
public class User2 implements Externalizable {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeInt(age);
    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name = (String) in.readObject();
        age = in.readInt();
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
} 

package com.hollischaung.serialization.ExternalizableDemos;

import java.io.*;

/**
 * Created by hollis on 16/2/17.
 */
public class ExternalizableDemo2 {

    //為了便於理解和節省篇幅，忽略關閉流操作及刪除文件操作。真正編碼時千萬不要忘記
    //IOException直接拋出
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //Write Obj to file
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
        User2 user = new User2();
        user.setName("hollis");
        user.setAge(23);
        oos.writeObject(user);
        //Read Obj from file
        File file = new File("tempFile");
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        User2 newInstance = (User2) ois.readObject();
        //output
        System.out.println(newInstance);
    }
}
//OutPut:
//User{name='hollis', age=23} 

這次，就可以把之前的對象狀態持久化下來了。

如果User類中沒有無參數的構造函數，在運行時會拋出異常：java.io.InvalidClassException

ObjectOutputStream類和ObjectInputStream類

通過前面的代碼片段中我們也能知道，我們一般使用ObjectOutputStream的writeObject方法把一個對象進行持久化。再使用ObjectInputStream的readObject從持久化存儲中把對象讀取出來。

注意：writeObject()方法存儲Field的順序應該和readObject()方法中恢復Field的順序一致，否則將不能正常恢復該Java對象。

對象的序列化過程通過ObjectOutputStream和ObjectInputputStream來實現的。

這里給出ObjectOutputStream的writeObject的調用棧：

writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData--->invokeWriteObject 

這里看一下invokeWriteObject：

void invokeWriteObject(Object obj, ObjectOutputStream out)
        throws IOException, UnsupportedOperationException
    {
        if (writeObjectMethod != null) {
            try {
                writeObjectMethod.invoke(obj, new Object[]{ out });
            } catch (InvocationTargetException ex) {
                Throwable th = ex.getTargetException();
                if (th instanceof IOException) {
                    throw (IOException) th;
                } else {
                    throwMiscException(th);
                }
            } catch (IllegalAccessException ex) {
                // should not occur, as access checks have been suppressed
                throw new InternalError(ex);
            }
        } else {
            throw new UnsupportedOperationException();
        }
    } 

其中writeObjectMethod.invoke(obj, new Object[]{ out });是關鍵，通過反射的方式調用writeObjectMethod方法。官方是這么解釋這個writeObjectMethod的：

class-defined writeObject method, or null if none

至此，我們先試着來回答以下的問題：

如果一個類中包含writeObject 和 readObject 方法，那么這兩個方法是怎么被調用的?

答：在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法時，會通過反射的方式調用。

---

那么，不知道有沒有人提出這樣的疑問： 

Serializable明明就是一個空的接口，它是怎么保證只有實現了該接口的方法才能進行序列化與反序列化的呢？

Serializable接口的定義：

public interface Serializable {
}

 

其實這個問題也很好回答，我們再回到剛剛ObjectOutputStream的writeObject的調用棧：

writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData--->invokeWriteObject

 

writeObject0方法中有這么一段代碼：

if (obj instanceof String) {
                writeString((String) obj, unshared);
            } else if (cl.isArray()) {
                writeArray(obj, desc, unshared);
            } else if (obj instanceof Enum) {
                writeEnum((Enum<?>) obj, desc, unshared);
            } else if (obj instanceof Serializable) {
                writeOrdinaryObject(obj, desc, unshared);
            } else {
                if (extendedDebugInfo) {
                    throw new NotSerializableException(
                        cl.getName() + "\n" + debugInfoStack.toString());
                } else {
                    throw new NotSerializableException(cl.getName());
                }
            } 

在進行序列化操作時，會判斷要被序列化的類是否是Enum、Array和Serializable類型，如果不是則直接拋出NotSerializableException。

Transient 關鍵字

Transient 關鍵字的作用是控制變量的序列化，在變量聲明前加上該關鍵字，可以阻止該變量被序列化到文件中，在被反序列化后，transient 變量的值被設為初始值，如 int 型的是 0，對象型的是 null。Transient 關鍵字只能用於修飾Field，不可修飾Java程序中的其他成分。

序列化ID

虛擬機是否允許反序列化，不僅取決於類路徑和功能代碼是否一致，一個非常重要的一點是兩個類的序列化 ID 是否一致（就是 private static final long serialVersionUID)

序列化 ID 在 Eclipse 下提供了兩種生成策略，一個是固定的 1L，一個是隨機生成一個不重復的 long 類型數據（實際上是使用 JDK 工具生成），在這里有一個建議，如果沒有特殊需求，就是用默認的 1L 就可以，這樣可以確保代碼一致時反序列化成功。那么隨機生成的序列化 ID 有什么作用呢，有些時候，通過改變序列化 ID 可以用來限制某些用戶的使用。

對類的哪些修改可能導致該類實例的反序列化失敗呢？下面分三種情況來具體討論：

如果修改類時僅僅修改了方法，則反序列化不受任何影響，類定義無須修改serialVersionUID Field值；

如果修改類時僅僅修改了靜態Field或瞬態Field，則反序列化不受任何影響，類定義無須修改serialVersionUID Field值；

如果修改類時修改了非靜態Field、非瞬態Field，則可能導致序列化版本不兼容。如果對象流中的對象和新類中包含同名的Field，而Field類型不同，則反序列化失敗，類定義應該更新serialVersionUID Field值。如果對象流中的對象比新類中包含更多的Field，則多出的Field值被忽略，序列化版本可以兼容，類定義可以不更新serialVersionUID Field值；如果新類比對象流中的對象包含更多的Field，則序列化版本也可以兼容，類定義可以不更新serialVersionUID Field值；但反序列化得到的新對象中多出的Field值都是null（引用類型Field）或0（基本類型Field）。

防止序列化破壞單例模式

只要在Singleton類中定義readResolve就可以解決該問題：

package com.hollis;
import java.io.Serializable;
/**
 * Created by hollis on 16/2/5.
 * 使用雙重校驗鎖方式實現單例
 */
public class Singleton implements Serializable{
    private volatile static Singleton singleton;
    private Singleton (){}
    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    private Object readResolve() {
        return singleton;
    }
} 

還是運行以下測試類：

package com.hollis;
import java.io.*;
/**
 * Created by hollis on 16/2/5.
 */
public class SerializableDemo1 {
    //為了便於理解，忽略關閉流操作及刪除文件操作。真正編碼時千萬不要忘記
    //Exception直接拋出
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //Write Obj to file
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
        oos.writeObject(Singleton.getSingleton());
        //Read Obj from file
        File file = new File("tempFile");
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        Singleton newInstance = (Singleton) ois.readObject();
        //判斷是否是同一個對象
        System.out.println(newInstance == Singleton.getSingleton());
    }
}
//true 

本次輸出結果為true。主要在Singleton中定義readResolve方法，並在該方法中指定要返回的對象的生成策略，就可以防止單例被破壞。

所有的單例類、枚舉類在實現序列化時都應該提供readResolve()方法，這樣才可以保證反序列化的對象依然正常。通常的建議是，對於final類重寫readResolve()方法不會有任何問題；否則，重寫readResolve()方法時應盡量使用private修飾該方法。

總結

1、如果一個類想被序列化，需要實現Serializable接口。否則將拋出NotSerializableException異常，這是因為，在序列化操作過程中會對類型進行檢查，要求被序列化的類必須屬於Enum、Array和Serializable類型其中的任何一種。

2、在變量聲明前加上該關鍵字，可以阻止該變量被序列化到文件中。

3、在類中增加writeObject 和 readObject 方法可以實現自定義序列化策略。

4、在涉及到序列化的場景時，要格外注意他對單例的破壞。

參考資料

《成神之路-基礎篇》Java基礎知識——序列化（已完結）：http://www.hollischuang.com/archives/1158