Externalizable与Serializable

1.相互关系

 

   首先两者都是接口，Externalizable继承Serializable，并增加了两个方法声明，分别是writeExternal和readExternal。我画出了UML图来表现他们的关系，如下：

   

 

 2.Serializable介绍

 

    （1）Serializable接口没有定义方法，也没有任何常量定义，就一空接口。如果有类实现了Serializable接口，则等于告诉JVM此类是可序列化（序列化解释）的。

 

    （2）对于实现了Serializable接口的类，如果需要类的某个成员变量在序列化时被排除，不参与序列化，可在定义成员变量时，使用transient关键词，比如: private transient int a;

 

    （3）serialVersionUID，序列化版本号。 在implements Serializable实现接口时，你可以显示定义serialVersionUID常量，也可以不定义。在不定义的情况下，在编译期间默认会根据类名、方法名、成员变量名等通过一定算法自动生成一个。它是用来识别类的版本的。比如你序列化后，对原本的类作了修改，如果serialVersionUID是你显示定义的，那反序列化还是可以正常进行，因为UID没变。否则，在你修改了类、方法、成员变量名的情况下，自动生成的UID就跟序列化时不一样了，这时候反序列化会失败。通常见到的提示像这样的：

        
      测试代码如下:

     

Java代码 

 

1. package com.wind.DbTec.sqlpkg;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7. import java.io.ObjectInputStream;  
8. import java.io.ObjectOutputStream;  
9. import java.io.Serializable;  
10.   
11. /** 
12.  * Serializable的serialVersionUID的作用，类版本控制 默认UID会根据类名，方法名，属性名自动生成，也可以显示定义 
13.  *  
14.  * @author zhouyanjun 
15.  * @version 1.0 2014-12-9 
16.  */  
17. public class SeriIDTest implements Serializable {  
18.     /** 
19.      *  
20.      */  
21.     private static final long serialVersionUID = -8488760619565425801L;  //这里显示定义了  
22.     int company_id;  
23.     String company_addr;  
24.   
25.     // int index;  
26.   
27.     public SeriIDTest(int company_id, String company_addr) {  
28.         this.company_id = company_id;  
29.         this.company_addr = company_addr;  
30.     }  
31.   
32.     public String toString() {  
33.         return "DATA:" + company_id + " " + company_addr;  
34.     }  
35.   
36.     public void todo() {  
37.     } // 添加一个无关紧要的方法  
38.   
39.     public static void main(String[] args) {  
40.         try {  
41.             ObjectOutputStream objWriter = new ObjectOutputStream(  
42.                     new FileOutputStream("D://serId.txt"));  
43.             SeriIDTest seriTest = new SeriIDTest(12, "suzhou");  
44.             objWriter.writeObject(seriTest);  
45.   
46.             ObjectInputStream objReader = new ObjectInputStream(  
47.                     new FileInputStream("D://serId.txt"));  
48.             SeriIDTest seriTest1 = (SeriIDTest) objReader.readObject();  
49.             System.out.println(seriTest1);  
50.         } catch (FileNotFoundException e) {  
51.             e.printStackTrace();  
52.         } catch (IOException e) {  
53.             e.printStackTrace();  
54.         } catch (ClassNotFoundException e) {  
55.             e.printStackTrace();  
56.         } catch (Exception e) {  
57.             e.printStackTrace();  
58.         }  
59.     }  
60. }  

 

 

3. Externalizable介绍

 

    （1）Externalizable接口提供的writeExternal和readExternal两个方法，给予开发者序列化实现的可控(可以决定哪些字段参与序列化，或者在序列化前后对一些字段值做些修改等)

 

    （2）在实现Externalizable接口时，writeExternal,readExternal两方法的传入参数为ObjectOutputStream和ObjectInputStream,方法内只能调用他们的writeObject和readObject方法，其他方法无法完成序列化；

 

      测试代码如下：

      

Java代码 

 

1. package com.wind.DbTec.sqlpkg;  
2.   
3. import java.io.Externalizable;  
4. import java.io.FileInputStream;  
5. import java.io.FileNotFoundException;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8. import java.io.ObjectInput;  
9. import java.io.ObjectInputStream;  
10. import java.io.ObjectOutput;  
11. import java.io.ObjectOutputStream;  
12.   
13. /** 
14.  * Externalizable的学习，基于与Serializable的区别 
15.  *  
16.  * @author zhouyanjun 
17.  * @version 1.0 2014-12-8 
18.  */  
19. public class ExternalizableTest implements Externalizable {  
20.     private String letterstates = "fanruijun";  
21.     private int num = 0;  
22.   
23.     public void writeExternal(ObjectOutput out) throws IOException {  
24.         // TODO Auto-generated method stub  
25.         out.writeObject(letterstates);  
26.         out.writeObject(num);  
27.         //out.writeChar('s');  //不使用writeObject,而使用writeChar  
28.     }  
29.   
30.     public void readExternal(ObjectInput in) throws IOException,  
31.             ClassNotFoundException {  
32.         // TODO Auto-generated method stub  
33.         letterstates = (String) in.readObject();  
34.         num = (Integer) in.readObject();  
35.         //System.out.println(in.readChar());  //不使用readObject,而使用readChar  
36.     }  
37.   
38.     public String toString() {  
39.         return "value:" + letterstates + " " + num;  
40.     }  
41.   
42.     public static void main(String[] args) {  
43.         try {  
44.             ExternalizableTest myTest = new ExternalizableTest();  
45.             // 序列化对象写入文件  
46.             ObjectOutput out = new ObjectOutputStream(new FileOutputStream(  
47.                     "D://MyTest.txt"));  
48.             myTest.writeExternal(out);  
49.             myTest.num = 3;  
50.             System.out.println(myTest);  
51.   
52.             // 从文件读取  
53.             ObjectInput in = new ObjectInputStream(new FileInputStream(  
54.                     "D://MyTest.txt"));  
55.             myTest.readExternal(in);  
56.             System.out.println(myTest);  
57.         } catch (FileNotFoundException e) {  
58.             // TODO Auto-generated catch block  
59.             e.printStackTrace();  
60.         } catch (IOException e) {  
61.             // TODO Auto-generated catch block  
62.             e.printStackTrace();  
63.         } catch (ClassNotFoundException e) {  
64.             // TODO Auto-generated catch block  
65.             e.printStackTrace();  
66.         }  
67.     }  
68. }