:notebook: 本文已歸檔到：「blog」
:keyboard: 本文中的示例程式碼已歸檔到：「javacore」
簡介
- 序列化（serialize） - 序列化是將物件轉換為位元組流。
- 反序列化（deserialize） - 反序列化是將位元組流轉換為物件。
- 序列化用途
- 序列化可以將物件的位元組序列持久化——儲存在記憶體、檔案、資料庫中。
- 在網路上傳送物件的位元組序列。
- RMI(遠端方法呼叫)
:bell: 注意：使用 Java 物件序列化，在儲存物件時，會把其狀態儲存為一組位元組，在未來，再將這些位元組組裝成物件。必須注意地是，物件序列化儲存的是物件的”狀態”，即它的成員變數。由此可知，物件序列化不會關注類中的靜態變數。
序列化和反序列化
Java 通過物件輸入輸出流來實現序列化和反序列化：
java.io.ObjectOutputStream類的writeObject()方法可以實現序列化；java.io.ObjectInputStream類的readObject()方法用於實現反序列化。
序列化和反序列化示例：
public class SerializeDemo01 {
enum Sex {
MALE,
FEMALE
}
static class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name = null;
private Integer age = null;
private Sex sex;
public Person() { }
public Person(String name, Integer age, Sex sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
@Override
public String toString() {
return "Person{" + "name='" + name + '\'' + ", age=" + age + ", sex=" + sex + '}';
}
}
/**
* 序列化
*/
private static void serialize(String filename) throws IOException {
File f = new File(filename); // 定義儲存路徑
OutputStream out = new FileOutputStream(f); // 檔案輸出流
ObjectOutputStream oos = new ObjectOutputStream(out); // 物件輸出流
oos.writeObject(new Person("Jack", 30, Sex.MALE)); // 儲存物件
oos.close();
out.close();
}
/**
* 反序列化
*/
private static void deserialize(String filename) throws IOException, ClassNotFoundException {
File f = new File(filename); // 定義儲存路徑
InputStream in = new FileInputStream(f); // 檔案輸入流
ObjectInputStream ois = new ObjectInputStream(in); // 物件輸入流
Object obj = ois.readObject(); // 讀取物件
ois.close();
in.close();
System.out.println(obj);
}
public static void main(String[] args) throws IOException, ClassNotFoundException {
final String filename = "d:/text.dat";
serialize(filename);
deserialize(filename);
}
}
// Output:
// Person{name='Jack', age=30, sex=MALE}
複製程式碼Serializable 介面
被序列化的類必須屬於 Enum、Array 和 Serializable 型別其中的任何一種。
如果不是 Enum、Array 的類，如果需要序列化，必須實現 java.io.Serializable 介面，否則將丟擲 NotSerializableException 異常。這是因為：在序列化操作過程中會對型別進行檢查，如果不滿足序列化型別要求，就會丟擲異常。
我們不妨做一個小嚐試：將 SerializeDemo01 示例中 Person 類改為如下實現，然後看看執行結果。
public class UnSerializeDemo {
static class Person { // 其他內容略 }
// 其他內容略
}
複製程式碼輸出：結果就是出現如下異常資訊。
Exception in thread "main" java.io.NotSerializableException:
...
複製程式碼serialVersionUID
請注意 serialVersionUID 欄位，你可以在 Java 世界的無數類中看到這個欄位。
serialVersionUID 有什麼作用，如何使用 serialVersionUID？
serialVersionUID 是 Java 為每個序列化類產生的版本標識。它可以用來保證在反序列時，傳送方傳送的和接受方接收的是可相容的物件。如果接收方接收的類的 serialVersionUID 與傳送方傳送的 serialVersionUID 不一致，會丟擲 InvalidClassException。
如果可序列化類沒有顯式宣告 serialVersionUID，則序列化執行時將基於該類的各個方面計算該類的預設 serialVersionUID 值。儘管這樣，還是建議在每一個序列化的類中顯式指定 serialVersionUID 的值。因為不同的 jdk 編譯很可能會生成不同的 serialVersionUID 預設值，從而導致在反序列化時丟擲 InvalidClassExceptions 異常。
serialVersionUID 欄位必須是 static final long 型別。
我們來舉個例子：
（1）有一個可序列化類 Person
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private Integer age;
private String address;
// 構造方法、get、set 方法略
}
複製程式碼（2）開發過程中，對 Person 做了修改，增加了一個欄位 email，如下：
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private Integer age;
private String address;
private String email;
// 構造方法、get、set 方法略
}
複製程式碼由於這個類和老版本不相容，我們需要修改版本號：
private static final long serialVersionUID = 2L;
複製程式碼再次進行反序列化，則會丟擲 InvalidClassException 異常。
綜上所述，我們大概可以清楚：serialVersionUID 用於控制序列化版本是否相容。若我們認為修改的可序列化類是向後相容的，則不修改 serialVersionUID。
預設序列化機制
如果僅僅只是讓某個類實現 Serializable 介面，而沒有其它任何處理的話，那麼就會使用預設序列化機制。
使用預設機制，在序列化物件時，不僅會序列化當前物件本身，還會對其父類的欄位以及該物件引用的其它物件也進行序列化。同樣地，這些其它物件引用的另外物件也將被序列化，以此類推。所以，如果一個物件包含的成員變數是容器類物件，而這些容器所含有的元素也是容器類物件，那麼這個序列化的過程就會較複雜，開銷也較大。
注意：這裡的父類和引用物件既然要進行序列化，那麼它們當然也要滿足序列化要求：被序列化的類必須屬於 Enum、Array 和 Serializable 型別其中的任何一種。
非預設序列化機制
在現實應用中，有些時候不能使用預設序列化機制。比如，希望在序列化過程中忽略掉敏感資料，或者簡化序列化過程。下面將介紹若干影響序列化的方法。
transient 關鍵字
當某個欄位被宣告為 transient 後，預設序列化機制就會忽略該欄位。
我們將 SerializeDemo01 示例中的內部類 Person 的 age 欄位宣告為 transient，如下所示：
public class SerializeDemo02 {
static class Person implements Serializable {
transient private Integer age = null;
// 其他內容略
}
// 其他內容略
}
// Output:
// name: Jack, age: null, sex: MALE
複製程式碼從輸出結果可以看出，age 欄位沒有被序列化。
Externalizable 介面
無論是使用 transient 關鍵字，還是使用 writeObject() 和 readObject() 方法，其實都是基於 Serializable 介面的序列化。
JDK 中提供了另一個序列化介面--Externalizable。
可序列化類實現 Externalizable 介面之後，基於 Serializable 介面的預設序列化機制就會失效。
我們來基於 SerializeDemo02 再次做一些改動，程式碼如下：
public class ExternalizeDemo01 {
static class Person implements Externalizable {
transient private Integer age = null;
// 其他內容略
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(age);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
age = in.readInt();
}
@Override
public void writeExternal(ObjectOutput out) throws IOException { }
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { }
}
// 其他內容略
}
// Output:
// call Person()
// name: null, age: null, sex: null
複製程式碼從該結果，一方面可以看出 Person 物件中任何一個欄位都沒有被序列化。另一方面，如果細心的話，還可以發現這此次序列化過程呼叫了 Person 類的無參構造方法。
Externalizable繼承於Serializable，它增添了兩個方法：writeExternal()與readExternal()。這兩個方法在序列化和反序列化過程中會被自動呼叫，以便執行一些特殊操作。當使用該介面時，序列化的細節需要由程式設計師去完成。如上所示的程式碼，由於writeExternal()與readExternal()方法未作任何處理，那麼該序列化行為將不會儲存/讀取任何一個欄位。這也就是為什麼輸出結果中所有欄位的值均為空。- 另外，若使用 Externalizable 進行序列化，當讀取物件時，會呼叫被序列化類的無參構造方法去建立一個新的物件；然後再將被儲存物件的欄位的值分別填充到新物件中。這就是為什麼在此次序列化過程中 Person 類的無參構造方法會被呼叫。由於這個原因，實現
Externalizable介面的類必須要提供一個無參的構造方法，且它的訪問許可權為public。
對上述 Person 類作進一步的修改，使其能夠對 name 與 age 欄位進行序列化，但要忽略掉 gender 欄位，如下程式碼所示：
public class ExternalizeDemo02 {
static class Person implements Externalizable {
transient private Integer age = null;
// 其他內容略
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(age);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
age = in.readInt();
}
@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();
}
}
// 其他內容略
}
// Output:
// call Person()
// name: Jack, age: 30, sex: null
複製程式碼Externalizable 介面的替代方法
實現 Externalizable 介面可以控制序列化和反序列化的細節。它有一個替代方法：實現 Serializable 介面，並新增 writeObject(ObjectOutputStream out) 與 readObject(ObjectInputStream in) 方法。序列化和反序列化過程中會自動回撥這兩個方法。
示例如下所示：
public class SerializeDemo03 {
static class Person implements Serializable {
transient private Integer age = null;
// 其他內容略
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(age);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
age = in.readInt();
}
// 其他內容略
}
// 其他內容略
}
// Output:
// name: Jack, age: 30, sex: MALE
複製程式碼在 writeObject() 方法中會先呼叫 ObjectOutputStream 中的 defaultWriteObject() 方法，該方法會執行預設的序列化機制，如上節所述，此時會忽略掉 age 欄位。然後再呼叫 writeInt() 方法顯示地將 age 欄位寫入到 ObjectOutputStream 中。readObject() 的作用則是針對物件的讀取，其原理與 writeObject() 方法相同。
注意：
writeObject()與readObject()都是private方法，那麼它們是如何被呼叫的呢？毫無疑問，是使用反射。詳情可見ObjectOutputStream中的writeSerialData方法，以及ObjectInputStream中的readSerialData方法。
readResolve() 方法
當我們使用 Singleton 模式時，應該是期望某個類的例項應該是唯一的，但如果該類是可序列化的，那麼情況可能會略有不同。此時對第 2 節使用的 Person 類進行修改，使其實現 Singleton 模式，如下所示：
public class SerializeDemo04 {
enum Sex {
MALE, FEMALE
}
static class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name = null;
transient private Integer age = null;
private Sex sex;
static final Person instatnce = new Person("Tom", 31, Sex.MALE);
private Person() {
System.out.println("call Person()");
}
private Person(String name, Integer age, Sex sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public static Person getInstance() {
return instatnce;
}
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(age);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
age = in.readInt();
}
public String toString() {
return "name: " + this.name + ", age: " + this.age + ", sex: " + this.sex;
}
}
/**
* 序列化
*/
private static void serialize(String filename) throws IOException {
File f = new File(filename); // 定義儲存路徑
OutputStream out = new FileOutputStream(f); // 檔案輸出流
ObjectOutputStream oos = new ObjectOutputStream(out); // 物件輸出流
oos.writeObject(new Person("Jack", 30, Sex.MALE)); // 儲存物件
oos.close();
out.close();
}
/**
* 反序列化
*/
private static void deserialize(String filename) throws IOException, ClassNotFoundException {
File f = new File(filename); // 定義儲存路徑
InputStream in = new FileInputStream(f); // 檔案輸入流
ObjectInputStream ois = new ObjectInputStream(in); // 物件輸入流
Object obj = ois.readObject(); // 讀取物件
ois.close();
in.close();
System.out.println(obj);
System.out.println(obj == Person.getInstance());
}
public static void main(String[] args) throws IOException, ClassNotFoundException {
final String filename = "d:/text.dat";
serialize(filename);
deserialize(filename);
}
}
// Output:
// name: Jack, age: null, sex: MALE
// false
複製程式碼值得注意的是，從檔案中獲取的 Person 物件與 Person 類中的單例物件並不相等。為了能在單例類中仍然保持序列的特性，可以使用 readResolve() 方法。在該方法中直接返回 Person 的單例物件。我們在 SerializeDemo04 示例的基礎上新增一個 readObject 方法， 如下所示：
public class SerializeDemo05 {
// 其他內容略
static class Person implements Serializable {
// 新增此方法
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
age = in.readInt();
}
// 其他內容略
}
// 其他內容略
}
// Output:
// name: Tom, age: 31, sex: MALE
// true
複製程式碼序列化工具
Java 官方的序列化存在許多問題，因此，很多人更願意使用優秀的第三方序列化工具來替代 Java 自身的序列化機制。
Java 官方的序列化主要體現在以下方面：
- Java 官方的序列化效能不高，序列化後的資料相對於一些優秀的序列化的工具，還是要大不少，這大大影響儲存和傳輸的效率。
- Java 官方的序列化一定需要實現 Serializable 介面。
- Java 官方的序列化需要關注 serialVersionUID。
- Java 官方的序列無法跨語言使用。
當然我們還有更加優秀的一些序列化和反序列化的工具，根據不同的使用場景可以自行選擇！
- thrift、protobuf - 適用於對效能敏感，對開發體驗要求不高的內部系統。
- hessian - 適用於對開發體驗敏感，效能有要求的內外部系統。
- jackson、gson、fastjson - 適用於對序列化後的資料要求有良好的可讀性（轉為 json 、xml 形式）。
小結
