Java中的序列化與反序列化

序列化和反序列化是通過ObjectInputStream和ObjectOutputStream的readObject()和writeObject()實現的，序列化的過程是一個對象流狀態保存的過程，這裡什麼叫對象流，可以理解為一系列的對象，因為本身一個對象的內部的字段都是一個個對象，實際上是通過“級聯”的方式，保存跟此對象所有關聯的對象的狀態，實際上保存了跟此對象有關系的一張“對象網”。

反序列化是還原對象狀態的過程，這種還原的過程可能在同一個應用中，可能在不同的應用中，可能在不同的主機上，還原的過程不是讀出原來對象的字段值然後調用構造函數重新new一個對象，而是“直接地”反序列化為一個Object對象，並沒有調用該類的構造函數，jvm也沒有加載該類到方法區，還原後的對象若在不同的主機，想通過反射獲得更多改對象的描述信息，必須保證JVM能在本地類路徑或者因特網的其他什麼地方找到相關的.class文件。

序列化也可以自己控制，使用Externalizable接口，此接口繼承自Serializable接口，和Serializable不同的是，使用Externalizable接口，在恢復對象的時候是調用的該類的無參構造方法，若無參構造方法不是public的，在恢復對象的時候會拋出異常，下面的代碼節選自Think in java

1. package externalizable; 
2.  
3. import java.io.Externalizable; 
4. import java.io.IOException; 
5. import java.io.ObjectInput; 
6. import java.io.ObjectOutput; 
7.  
8. public class Blip1 implements Externalizable { 
9.     //public的構造方法，在回復對象的時候被調用。  
10.     public Blip1() { 
11.         System.out.println("Blip1 Constructor"); 
12.     } 
13.  
14.     //在writeObject()方法的時候，會調用此方法  
15.     public void writeExternal(ObjectOutput out) throws IOException { 
16.         System.out.println("Blip1.writeExternal"); 
17.     } 
18.  
19.     //在readObject()方法的時候，會調用此方法  
20.     public void readExternal(ObjectInput in) throws IOException, 
21.             ClassNotFoundException { 
22.         System.out.println("Blip1.readExternal"); 
23.     } 
24.  
25. } 

1. package externalizable; 
2.  
3. import java.io.Externalizable; 
4. import java.io.IOException; 
5. import java.io.ObjectInput; 
6. import java.io.ObjectOutput; 
7.  
8. public class Blip2 implements Externalizable { 
9.     //此構造方法不是public的  
10.     Blip2() { 
11.         System.out.println("Blip2 Constructor"); 
12.     } 
13.  
14.     public void writeExternal(ObjectOutput out) throws IOException { 
15.         System.out.println("Blip2.writeExternal"); 
16.     } 
17.  
18.     public void readExternal(ObjectInput in) throws IOException, 
19.             ClassNotFoundException { 
20.         System.out.println("Blip2.readExternal"); 
21.     } 
22. } 

1. package externalizable; 
2.  
3. import java.io.FileInputStream; 
4. import java.io.FileOutputStream; 
5. import java.io.ObjectInputStream; 
6. import java.io.ObjectOutputStream; 
7.  
8. public class Blips { 
9.     public static void main(String[] args) { 
10.         System.out.println("Constructing objects:"); 
11.         Blip1 b1 = new Blip1(); 
12.         Blip2 b2 = new Blip2(); 
13.         try { 
14.             ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream( 
15.                     "Blips.out")); 
16.             System.out.println("Saving objects:"); 
17.             o.writeObject(b1); 
18.             o.writeObject(b2); 
19.             o.close(); 
20.             // Now get them back:  
21.             ObjectInputStream in = new ObjectInputStream(new FileInputStream( 
22.                     "Blips.out")); 
23.             System.out.println("Recovering b1:"); 
24.             b1 = (Blip1) in.readObject(); 
25.             // OOPS! Throws an exception:  
26.             // !System.out.println("Recovering b2:");  
27.             // !b2 = (Blip2) in.readObject();  
28.         } catch (Exception e) { 
29.             e.printStackTrace(); 
30.         } 
31.     } 
32. } 

輸入的結果為：

Constructing objects:
Blip1 Constructor
Blip2 Constructor
Saving objects:
Blip1.writeExternal
Blip2.writeExternal
Recovering b1:
Blip1 Constructor
Blip1.readExternal