Java序列化之Serializable_ZenDei技術網路在線

Java的序列化流程如下： Java的反序列化流程如下：註意：並不是所有類都需要進行序列化，主要原因有兩個 1）安全問題。Java中有的類屬於敏感類，此類的對象數據不便對外公開，而序列化的對象數據很容易進行破解，無法保證其數據的安全性，因此一般這種類型的對象不會進行序列化。 2）資源問題。可以使用 ...

Java的序列化流程如下：

Java的反序列化流程如下：

註意：並不是所有類都需要進行序列化，主要原因有兩個

1）安全問題。Java中有的類屬於敏感類，此類的對象數據不便對外公開，而序列化的對象數據很容易進行破解，無法保證其數據的安全性，因此一般這種類型的對象不會進行序列化。

2）資源問題。可以使用序列化位元組流創建對象，而且這種創建時不受限制的，有時過多地創建對象會造成很大的資源問題，因此此類對象也不適宜進行序列化。

Serializable

Serializable是Java提供的一個序列化介面，它是一個空介面，專門為對象提供標準的序列化跟反序列化操作。

序列化過程：

1 Person p = new Person("name","id");
2         File file = new File("cache.txt");
3         FileOutputStream output = new FileOutputStream(file);
4         ObjectOutputStream objectOutputStream = new ObjectOutputStream(output);
5         objectOutputStream.writeObject(p);
6         output.close();
7         objectOutputStream.close();

反序列化過程：

1 　　　　 File file = new File("cache.txt");
2         FileInputStream input= new FileInputStream(file);
3         ObjectInputStream objectInputStream = new ObjectInputStream(input);
4         Person p = (Person)objectInputStream.readObject();
5         System.out.println(p.getName()+"---"+p.getId());
6         input.close();
7         objectInputStream.close();

需要序列化的類成員

　　　　對象序列化時並不是所有成員都要轉換成二進位的位元組序列，因為為了節省存儲或傳輸空間以及提高序列化效率，有些不必要的成員是無需序列化的。其中包括：

- 　　靜態變數。因為靜態變數屬於類的屬性，並不屬於某個具體實例，因此在序列化的時候無須進行序列化，反序列化時，可以直接獲取類的靜態成員引用。
- 　　方法。方法只是一系列的操作集合，方法不會依賴對象，不會因為對象的不同，而操作不同，反序列化時，也可以從類中直接獲取方法信息。

繼承關係的序列化
- 父類實現Serializable時，子類被序列化，父類也會被序列化。
- 父類沒有實現Serializable時，子類被序列化，父類不會被序列化

引用關係的序列化

　　　　如果對一個實現了Serializable的類進行序列化操作，則同時對它的引用類進行序列化操作。如果引用類沒有實現Serializable介面，JVM會拋出java.io.NotSerializableExeception.

1 class Person implements Serializable{
2     private String name;
3     private Tool tool = new Tool();
4 }
5 
6 class Tool implements Serializable{
7     
8 }

　　此時對Person類進行序列化操作，則會同時對Tool類進行序列化操作。若Tool類沒有實現Serializable介面，則會拋出異常。

保護敏感數據：
- 　　一個類加上序列化標識後，該類對象的所有屬性信息將被序列化，然後進行本地存儲或網路傳輸。然後有時對象中的某些欄位屬於敏感信息，不應暴露出來。如果對其也進行序列化，容易被破解，從而造成安全隱患，例如常見的密碼欄位。
- 　　Java提供一個關鍵字transient，即瞬時關鍵字。該關鍵字關閉欄位的序列化，這樣受保護的信息就不會因為序列化而對外暴露。

序列化標識ID
- 　　試想一下這樣的情景：兩端進行網路傳輸序列化對象，由於某種原因，導致兩端使用的類的版本不同，假設接收方的類被刪除了幾個欄位。當發送發將對象的序列化位元組流發送到接收方時，由於接收方的類少了幾個欄位，而無法解析。
- 　　Java要求實現序列化介面的類都必須聲明一個serialVersionUID靜態屬性，如果沒有該屬性JVM也會自動聲明該屬性，併為該屬性賦值（當類發生改變時會賦予不同的值）。該屬性的值是唯一的，用於標識不同的序列化類。只有類的序列化標識完全相同，Java才會進行反序列化工作，這就是序列化標識的作用。
- 　　對於前面提到的情景，假設沒有手動聲明serialVersionUID，則JVM對發送方跟接收方使用的類中的serialVersionUID賦予不同的值，則反序列化失敗。當手動給serialVersionUID賦值時，即使類的字段發生改變，也能夠反序列化成功。

自定義序列化策略
- 　　定製序列化策略

　　　　　　Java提供了一套有效的機制，允許在序列化和反序列化時，使用定製的方法進行相應的處理。當傳輸雙方協定好序列化策略後，只需要在需要傳輸的序列化類中添加一組方法來實現這組策略，在序列化時會自動調用這些規定好的方法進行序列化和反序列化。方法如下：

　　　 1）private void writeObject(ObjectOutputSteam out) throws IOException　　

　　在方法的內部有重要的代碼：out.defaultWriteObject() 　　//將對象數據以預設方式寫入到輸出流中

　　　2）private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException

　　同樣的，此方法內部也有相似代碼：in.defaultReadObject();　　//以預設方式從輸入流中恢復對象

這兩個方法的作用分別是將特定的對象寫入到輸出流中以及從輸入流中恢復特定的對象，通過這兩個方法，用戶即可實現自定義的序列化。當在實現Serializable介面的類中寫了上面兩個方法之後，序列化或反序列化該類時則會通過反射來調用這兩個方法，從而實現自定義序列化。

- 　　限制序列化對象的數量

　　　　　　我們看下麵的單例模式：

 1 public class Singleton implements Serializable {
 2 
 3     private volatile static Singleton mInstance;
 4     private Singleton() {
 5     }
 6 
 7     public static Singleton getInstance() {
 8         if (mInstance == null) {
 9             synchronized (Singleton.class) {
10                 if (mInstance == null) {
11                     mInstance = new Singleton();
12                 }
13             }
14         }
15         return mInstance;
16     }
17 }

　　此時通過反序列化獲取實例，則單例模式會失效。那該如何解決這個問題呢？

　　Java有一種機制，可以讓我們在序列化和反序列化時，可以根據自己的需要，寫入或讀取指定的實例。使用這種機制，需要在實現Serializable介面的類中添加兩個方法：

　　　　private Object readResolve() 　　//如果用戶在序列化類中添加了該方法，則在進行反序列化時，使用該方法返回的對象，作為反序列化對象。
　　　　private Object writeReplace() 　　//如果用戶在序列化類中添加了該方法，則在進行序列化時，序列化該類返回的對象。

　　　　　　再看使用了該機制的單例模式：

 1  1 public class Singleton implements Serializable {
 2  2 
 3  3     private volatile static Singleton mInstance;
 4  4     private Singleton() {
 5  5     }
 6  6 
 7  7     public static Singleton getInstance() {
 8  8         if (mInstance == null) {
 9  9             synchronized (Singleton.class) {
10 10                 if (mInstance == null) {
11 11                     mInstance = new Singleton();
12 12                 }
13 13             }
14 14         }
15 15         return mInstance;
16 16     }
17 17 
18 18     private Object readResolve() {
19 19         return getInstance();
20 20     }
21 21 
22 22     private Object writeReplace() {
23 23         return getInstance();
24 24     }
25 25 }

　　此時的通過反序列化得到的對象也是同一個，即單例模式依然有效!