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

時間  2019-11-30
標籤 java 對象 序列 欄目 Java 简体版
原文   原文鏈接

序列化的含義和意義

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

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

在Java中，對象的序列化與反序列化被普遍應用到RMI(遠程方法調用)及網絡傳輸中。一般建議：程序建立的每一個JavaBean類都實現Serializable。數組

相關接口及類

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

java.io.Serializableide

java.io.Externalizable函數

ObjectOutput工具

ObjectInput測試

ObjectOutputStreamui

ObjectInputStreamthis

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修飾該方法。

總結

一、若是一個類想被序列化，須要實現Serializable接口。不然將拋出NotSerializableException異常，這是由於，在序列化操做過程當中會對類型進行檢查，要求被序列化的類必須屬於Enum、Array和Serializable類型其中的任何一種。

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

三、在類中增長writeObject 和 readObject 方法能夠實現自定義序列化策略。

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

參考資料

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

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程