Java Serializable：明明就一個空的接口嘛

對於 Java 的序列化，我一直停留在最淺顯的認知上——把那個要序列化的類實現 Serializbale 接口就能夠了。我不肯意作更深刻的研究，由於會用就好了嘛。java

但隨着時間的推移，見到 Serializbale 的次數愈來愈多，我便對它產生了濃厚的興趣。是時候花點時間研究研究了。數組

0一、先來點理論

Java 序列化是 JDK 1.1 時引入的一組開創性的特性，用於將 Java 對象轉換爲字節數組，便於存儲或傳輸。此後，仍然能夠將字節數組轉換回 Java 對象原有的狀態。bash

序列化的思想是「凍結」對象狀態，而後寫到磁盤或者在網絡中傳輸；反序列化的思想是「解凍」對象狀態，從新得到可用的 Java 對象。markdown

再來看看序列化 Serializbale 接口的定義：網絡

public interface Serializable {
}
複製代碼

明明就一個空的接口嘛，居然可以保證明現了它的「類的對象」被序列化和反序列化？ide

0二、再來點實戰

在回答上述問題以前，咱們先來建立一個類（只有兩個字段，和對應的 getter/setter），用於序列化和反序列化。學習

class Wanger {
    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;
    }
}
複製代碼

再來建立一個測試類，經過 ObjectOutputStream 將「18 歲的王二」寫入到文件當中，實際上就是一種序列化的過程；再經過 ObjectInputStream 將「18 歲的王二」從文件中讀出來，實際上就是一種反序列化的過程。測試

public class Test {

    public static void main(String[] args) {
      // 初始化
        Wanger wanger = new Wanger();
        wanger.setName("王二");
        wanger.setAge(18);
        System.out.println(wanger);

        // 把對象寫到文件中
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));){
            oos.writeObject(wanger);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 從文件中讀出對象
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));){
            Wanger wanger1 = (Wanger) ois.readObject();
            System.out.println(wanger1);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}
複製代碼

不過，因爲 Wanger 沒有實現 Serializbale 接口，因此在運行測試類的時候會拋出異常，堆棧信息以下：this

java.io.NotSerializableException: com.cmower.java_demo.xuliehua.Wanger
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
	at com.cmower.java_demo.xuliehua.Test.main(Test.java:21)
複製代碼

順着堆棧信息，咱們來看一下 ObjectOutputStream 的 writeObject0() 方法。其部分源碼以下：spa

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());
    }
}
複製代碼

也就是說，ObjectOutputStream 在序列化的時候，會判斷被序列化的對象是哪種類型，字符串？數組？枚舉？仍是 Serializable，若是全都不是的話，拋出 NotSerializableException。

假如 Wanger 實現了 Serializable 接口，就能夠序列化和反序列化了。

class Wanger implements Serializable{
    private static final long serialVersionUID = -2095916884810199532L;
    
    private String name;
    private int age;
}
複製代碼

具體怎麼序列化呢？

以 ObjectOutputStream 爲例吧，它在序列化的時候會依次調用 writeObject()→writeObject0()→writeOrdinaryObject()→writeSerialData()→invokeWriteObject()→defaultWriteFields()。

private void defaultWriteFields(Object obj, ObjectStreamClass desc) throws IOException {
        Class<?> cl = desc.forClass();
        desc.checkDefaultSerialize();

        int primDataSize = desc.getPrimDataSize();
        desc.getPrimFieldValues(obj, primVals);
        bout.write(primVals, 0, primDataSize, false);

        ObjectStreamField[] fields = desc.getFields(false);
        Object[] objVals = new Object[desc.getNumObjFields()];
        int numPrimFields = fields.length - objVals.length;
        desc.getObjFieldValues(obj, objVals);
        for (int i = 0; i < objVals.length; i++) {
          
            try {
                writeObject0(objVals[i],
                             fields[numPrimFields + i].isUnshared());
            }
        }
    }
複製代碼

那怎麼反序列化呢？

以 ObjectInputStream 爲例，它在反序列化的時候會依次調用 readObject()→readObject0()→readOrdinaryObject()→readSerialData()→defaultReadFields()。

private void defaultWriteFields(Object obj, ObjectStreamClass desc) throws IOException {
        Class<?> cl = desc.forClass();
        desc.checkDefaultSerialize();

        int primDataSize = desc.getPrimDataSize();
        desc.getPrimFieldValues(obj, primVals);
        bout.write(primVals, 0, primDataSize, false);

        ObjectStreamField[] fields = desc.getFields(false);
        Object[] objVals = new Object[desc.getNumObjFields()];
        int numPrimFields = fields.length - objVals.length;
        desc.getObjFieldValues(obj, objVals);
        for (int i = 0; i < objVals.length; i++) {
          
            try {
                writeObject0(objVals[i],
                             fields[numPrimFields + i].isUnshared());
            }
        }
    }
複製代碼

我想看到這，你應該會恍然大悟的「哦」一聲了。Serializable 接口之因此定義爲空，是由於它只起到了一個標識的做用，告訴程序實現了它的對象是能夠被序列化的，但真正序列化和反序列化的操做並不須要它來完成。

0三、再來點注意事項

開門見山的說吧，static 和 transient 修飾的字段是不會被序列化的。

爲何呢？咱們先來證實，再來解釋緣由。

首先，在 Wanger 類中增長兩個字段。

class Wanger implements Serializable {
    private static final long serialVersionUID = -2095916884810199532L;

    private String name;
    private int age;

    public static String pre = "沉默";
    transient String meizi = "王三";

    @Override
    public String toString() {
        return "Wanger{" + "name=" + name + ",age=" + age + ",pre=" + pre + ",meizi=" + meizi + "}";
    }
}
複製代碼

其次，在測試類中打印序列化前和反序列化後的對象，並在序列化後和反序列化前改變 static 字段的值。具體代碼以下：

// 初始化
Wanger wanger = new Wanger();
wanger.setName("王二");
wanger.setAge(18);
System.out.println(wanger);

// 把對象寫到文件中
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));){
        oos.writeObject(wanger);
    } catch (IOException e) {
        e.printStackTrace();
    }
   
    // 改變 static 字段的值
Wanger.pre ="不沉默";

// 從文件中讀出對象
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));){
    Wanger wanger1 = (Wanger) ois.readObject();
    System.out.println(wanger1);
} catch (IOException | ClassNotFoundException e) {
    e.printStackTrace();
}
// Wanger{name=王二,age=18,pre=沉默,meizi=王三}
// Wanger{name=王二,age=18,pre=不沉默,meizi=null}

複製代碼

從結果的對比當中，咱們能夠發現：

1）序列化前，pre 的值爲「沉默」，序列化後，pre 的值修改成「不沉默」，反序列化後，pre 的值爲「不沉默」，而不是序列化前的狀態「沉默」。

爲何呢？由於序列化保存的是對象的狀態，而 static 修飾的字段屬於類的狀態，所以能夠證實序列化並不保存 static 修飾的字段。

2）序列化前，meizi 的值爲「王三」，反序列化後，meizi 的值爲 null，而不是序列化前的狀態「王三」。

爲何呢？transient 的中文字義爲「臨時的」（論英語的重要性），它能夠阻止字段被序列化到文件中，在被反序列化後，transient 字段的值被設爲初始值，好比 int 型的初始值爲 0，對象型的初始值爲 null。

若是想要深究源碼的話，你能夠在 ObjectStreamClass 中發現下面這樣的代碼：

private static ObjectStreamField[] getDefaultSerialFields(Class<?> cl) {
    Field[] clFields = cl.getDeclaredFields();
    ArrayList<ObjectStreamField> list = new ArrayList<>();
    int mask = Modifier.STATIC | Modifier.TRANSIENT;

    int size = list.size();
    return (size == 0) ? NO_FIELDS :
        list.toArray(new ObjectStreamField[size]);
}
複製代碼

看到 Modifier.STATIC | Modifier.TRANSIENT，是否是感受更好了呢？

0四、再來點乾貨

除了 Serializable 以外，Java 還提供了一個序列化接口 Externalizable（念起來有點拗口）。

兩個接口有什麼不同的嗎？試一試就知道了。

首先，把 Wanger 類實現的接口 Serializable 替換爲 Externalizable。

class Wanger implements Externalizable {
	private String name;
	private int age;

	public Wanger() {

	}

	public String getName() {
		return name;
	}

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

	@Override
	public void writeExternal(ObjectOutput out) throws IOException {

	}

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

	}

}
複製代碼

實現 Externalizable 接口的 Wanger 類和實現 Serializable 接口的 Wanger 類有一些不一樣：

1）新增了一個無參的構造方法。

使用 Externalizable 進行反序列化的時候，會調用被序列化類的無參構造方法去建立一個新的對象，而後再將被保存對象的字段值複製過去。不然的話，會拋出如下異常：

java.io.InvalidClassException: com.cmower.java_demo.xuliehua1.Wanger; no valid constructor
	at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150)
	at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:790)
	at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1782)
	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1353)
	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:373)
	at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27)
複製代碼

2）新增了兩個方法 writeExternal() 和 readExternal()，實現 Externalizable 接口所必須的。

而後，咱們再在測試類中打印序列化前和反序列化後的對象。

// 初始化
Wanger wanger = new Wanger();
wanger.setName("王二");
wanger.setAge(18);
System.out.println(wanger);

// 把對象寫到文件中
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));) {
	oos.writeObject(wanger);
} catch (IOException e) {
	e.printStackTrace();
}

// 從文件中讀出對象
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));) {
	Wanger wanger1 = (Wanger) ois.readObject();
	System.out.println(wanger1);
} catch (IOException | ClassNotFoundException e) {
	e.printStackTrace();
}
// Wanger{name=王二,age=18}
// Wanger{name=null,age=0}
複製代碼

從輸出的結果看，反序列化後獲得的對象字段都變成了默認值，也就是說，序列化以前的對象狀態沒有被「凍結」下來。

爲何呢？由於咱們沒有爲 Wanger 類重寫具體的 writeExternal() 和 readExternal() 方法。那該怎麼重寫呢？

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

@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
	name = (String) in.readObject();
	age = in.readInt();
}
複製代碼

1）調用 ObjectOutput 的 writeObject() 方法將字符串類型的 name 寫入到輸出流中；

2）調用 ObjectOutput 的 writeInt() 方法將整型的 age 寫入到輸出流中；

3）調用 ObjectInput 的 readObject() 方法將字符串類型的 name 讀入到輸入流中；

4）調用 ObjectInput 的 readInt() 方法將字符串類型的 age 讀入到輸入流中；

再運行一次測試了類，你會發現對象能夠正常地序列化和反序列化了。

序列化前：Wanger{name=王二,age=18} 序列化後：Wanger{name=王二,age=18}

0五、再來點甜點

讓我先問問你吧，你知道 private static final long serialVersionUID = -2095916884810199532L; 這段代碼的做用嗎？

嗯......

serialVersionUID 被稱爲序列化 ID，它是決定 Java 對象可否反序列化成功的重要因子。在反序列化時，Java 虛擬機會把字節流中的 serialVersionUID 與被序列化類中的 serialVersionUID 進行比較，若是相同則能夠進行反序列化，不然就會拋出序列化版本不一致的異常。

當一個類實現了 Serializable 接口後，IDE 就會提醒該類最好產生一個序列化 ID，就像下面這樣：

1）添加一個默認版本的序列化 ID：

private static final long serialVersionUID = 1L。
複製代碼

2）添加一個隨機生成的不重複的序列化 ID。

private static final long serialVersionUID = -2095916884810199532L;
複製代碼

3）添加 @SuppressWarnings 註解。

@SuppressWarnings("serial")
複製代碼

怎麼選擇呢？

首先，咱們採用第二種辦法，在被序列化類中添加一個隨機生成的序列化 ID。

class Wanger implements Serializable {
	private static final long serialVersionUID = -2095916884810199532L;
	
	private String name;
	private int age;

	// 其餘代碼忽略
}
複製代碼

而後，序列化一個 Wanger 對象到文件中。

// 初始化
Wanger wanger = new Wanger();
wanger.setName("王二");
wanger.setAge(18);
System.out.println(wanger);

// 把對象寫到文件中
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));) {
	oos.writeObject(wanger);
} catch (IOException e) {
	e.printStackTrace();
}
複製代碼

這時候，咱們悄悄地把 Wanger 類的序列化 ID 偷樑換柱一下，嘿嘿。

// private static final long serialVersionUID = -2095916884810199532L;
private static final long serialVersionUID = -2095916884810199533L;
複製代碼

好了，準備反序列化吧。

try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));) {
	Wanger wanger = (Wanger) ois.readObject();
	System.out.println(wanger);
} catch (IOException | ClassNotFoundException e) {
	e.printStackTrace();
}
複製代碼

哎呀，出錯了。

java.io.InvalidClassException:  local class incompatible: stream classdesc 
serialVersionUID = -2095916884810199532,
local class serialVersionUID = -2095916884810199533
	at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)
	at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27)
複製代碼

異常堆棧信息裏面告訴咱們，從持久化文件裏面讀取到的序列化 ID 和本地的序列化 ID 不一致，沒法反序列化。

那假如咱們採用第三種方法，爲 Wanger 類添加個 @SuppressWarnings("serial") 註解呢？

@SuppressWarnings("serial")
class Wanger3 implements Serializable {
// 省略其餘代碼
}
複製代碼

好了，再來一次反序列化吧。惋惜依然報錯。

java.io.InvalidClassException:  local class incompatible: stream classdesc 
serialVersionUID = -2095916884810199532, 
local class serialVersionUID = -3818877437117647968
	at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)
	at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27)
複製代碼

異常堆棧信息裏面告訴咱們，本地的序列化 ID 爲 -3818877437117647968，和持久化文件裏面讀取到的序列化 ID 仍然不一致，沒法反序列化。這說明什麼呢？使用 @SuppressWarnings("serial") 註解時，該註解會爲被序列化類自動生成一個隨機的序列化 ID。

由此能夠證實，Java 虛擬機是否容許反序列化，不只取決於類路徑和功能代碼是否一致，還有一個很是重要的因素就是序列化 ID 是否一致。

也就是說，若是沒有特殊需求，採用默認的序列化 ID（1L）就能夠，這樣能夠確保代碼一致時反序列化成功。

class Wanger implements Serializable {
	private static final long serialVersionUID = 1L;
// 省略其餘代碼
}
複製代碼

0六、再來點總結

寫這篇文章以前，我真沒想到：「空空其身」的Serializable 居然有這麼多能夠研究的內容！

寫完這篇文章以後，我不禁得想起理科狀元曹林菁說說過的一句話：「在學習中再小的問題也不放過，每一個知識點都要總結」——說得真真真真的對啊！