Java中的序列化与反序列化

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