Java中的序列化與反序列化

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

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

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

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

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

1. package externalizable;
3. import java.io.FileInputStream;
4. import java.io.FileOutputStream;
5. import java.io.ObjectInputStream;
6. import java.io.ObjectOutputStream;
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