你所不知道的Java序列化

 1 class Employee implements Serializable{
 2          private ZipFile zf=null;
 3          Employee(ZipFile zf){
 4                 this.zf=zf;
 5          } 
 6 }
 7 
 8 ObjectOutputStream oout=
 9 new ObjectOutputStream(new FileInputStream(new File("aaa.txt")));
10 oout.writeObject(new Employee(new ZipFile("c://.."));

 1 //父类对象不能序列化
 2 class Employee{ 
 3     private String name;
 4     Employee(String n){
 5         this.name=n;
 6     }
 7     public String getName(){
 8         return this.name;
 9     }
10 }
11 //子类对象可以序列化
12 class Manager extends Employee implements Serializable{
13     private int id;
14     Manager(String name, int id){
15         super(name);
16         this.id=id;
17     }
18 }
19 //序列化与反序列化测试
20 public static void main(String[] args) throws IOException, ClassNotFoundException{
21          File file=new File("E:/aaa.txt");
22     ObjectOutputStream oout=new ObjectOutputStream(new FileOutputStream(file));
23     oout.writeObject(new Manager("amao",123));
24     oout.close();
25     System.out.println("序列化成功");
26         
27     ObjectInputStream oin=new ObjectInputStream(new FileInputStream(file));
28     Object o=oin.readObject();
29     oin.close();
30     System.out.println("反序列化成功:"+((Manager) o).getName());
31 }

 1 //修改前的Employee
 2 class Employee implements Serializable{
 3     private String name;
 4     Employee(String n){
 5         this.name=n;
 6     }
 7     public String getName(){
 8         return this.name;
 9     }
10 }
11 //测试，打印SUID=5135178525467874279L
12 long serialVersionUID=ObjectStreamClass.lookup(Class.forName("Employee")).getSerialVersionUID();
13 System.out.println(serialVersionUID);
14 
15 //修改后的Employee
16 class Employee implements Serializable{
17     private String name1; //注意，这里略微改动一下数据域的名字
18     Employee(String n){
19         this.name1=n;
20     }
21     public String getName(){
22         return this.name1;
23     }
24 }
25 //测试，打印SUID=-2226350316230217613L
26 long serialVersionUID=ObjectStreamClass.lookup(Class.forName("Employee")).getSerialVersionUID();
27 System.out.println(serialVersionUID);

 1 //下面的方法从上到下进行调用
 2 writeObject(Object); 
 3 
 4 //ObjectOutputStream的writeObject方法
 5 public final void writeObject(Object obj) throws IOException { 
 6         writeObject0(obj, false);
 7 }
 8 
 9 //ObjectOutputStream, 底层写入Object的实现
10 private void writeObject0(Object obj, boolean unshared) {
11        if (obj instanceof Serializable) {
12         writeOrdinaryObject(obj, desc, unshared);
13 }
14 
15 //ObjectOutputStream
16 private void writeOrdinaryObject(Object obj, ObjectStreamClass desc,  boolean unshared) {
17        writeSerialData(obj, desc);
18 }
19 
20 //ObjectOutputStream, 对超类到子类的每个可序列化的类，写出数据域
21  private void writeSerialData(Object obj, ObjectStreamClass desc)  throws IOException{
22          //如果类中有writeObject(ObjectOutputStream)方法，则通过底层进行调用
23          if (slotDesc.hasWriteObjectMethod()) { 
24                 slotDesc.invokeWriteObject(obj, this);
25          }//如果没有此方法，则采用默认的写类数据域的方法。
26          else {//这个方法会对可序列化的对象中的数据域进行写出，但是如果这个数据域是不可序列化而且没有writeObject(ObjectOutputStream)方法的类对象，那么将抛出异常。
27         defaultWriteFields(obj, slotDesc);
28      }
29 }

 1 //自定义的一个可序列化的ZipFile，当然这个类不能继承JDK中的ZipFile，否则序列化将不可能完成。
 2 class SerializableZipFile implements Serializable{
 3     public ZipFile zf;
 4     //包含一个ZipFile对象
 5     SerializableZipFile(String filename) throws IOException{
 6         zf=new ZipFile(filename);
 7     }
 8     //对ZipFile中的文件名进行序列化，因为它是String类型的
 9     private void writeObject(ObjectOutputStream out)throws IOException{
10         out.writeObject(zf.getName());
11     }
12     //对应的，反序列化过程中JVM也会检查类似的一个私有方法。
13     private void readObject(ObjectInputStream in)throws IOException,ClassNotFoundException{
14         String filename=(String)in.readObject();
15         zf=new ZipFile(filename);
16     }
17 }
18 //测试
19 public static void main(String[] args) throws IOException, ClassNotFoundException{
20     //序列化
21         File file=new File("E:/aaa.txt");
22     ObjectOutputStream oout=new ObjectOutputStream(new FileOutputStream(file));
23     oout.writeObject(new SerializableZipFile("e:/aaa.zip"));
24     oout.close();
25     System.out.println("序列化成功");
26     //反序列化
27     ObjectInputStream oin=new ObjectInputStream(new FileInputStream(file));
28     Object o=oin.readObject();
29     oin.close();
30     System.out.println("反序列化成功:"+((SerializableZipFile) o).zf.getName());
31 }
32 //序列化成功
33 //反序列化成功:e:\aaa.zip