Java序列化与反序列化【实例】

源：http://www.cnblogs.com/bluesky5304/archive/2010/04/07/1706061.html；

基本概念：

序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。

序列化为一般文件，也序列化为XML文件（使用XStream）

用于序列化的实体类Person.java 代码如下（记得需要实现Serializable接口）：

[java]  view plain copy

1. import java.io.Serializable;  
2.   
3. @SuppressWarnings("serial")  
4. public class Person implements Serializable{  
5.     private String name;  
6.     private int age;  
7.     public Person(){  
8.           
9.     }  
10.     public Person(String str, int n){  
11.         System.out.println("Inside Person's Constructor");  
12.         name = str;  
13.         age = n;  
14.     }  
15.     String getName(){  
16.         return name;  
17.     }  
18.     int getAge(){  
19.         return age;  
20.     }  
21. }  

序列化、反序列化为一般的文件，SerializeToFlatFile.java类的代码如下：

[java]  view plain copy

1. import java.io.FileInputStream;  
2. import java.io.FileOutputStream;  
3. import java.io.ObjectInputStream;  
4. import java.io.ObjectOutputStream;  
5.   
6.   
7. public class SerializeToFlatFile {  
8.     public static void main(String[] args) {  
9.         SerializeToFlatFile ser = new SerializeToFlatFile();  
10.         ser.savePerson();  
11.         ser.restorePerson();          
12.     }  
13.       
14.     public void savePerson(){  
15.         Person myPerson = new Person("Jay",24);  
16.         try {  
17.             FileOutputStream fos = new FileOutputStream("E:\\workspace\\2010_03\\src\\myPerson.txt");  
18.             ObjectOutputStream oos = new ObjectOutputStream(fos);  
19.             System.out.println("Person--Jay,24---Written");  
20.             System.out.println("Name is: "+myPerson.getName());  
21.             System.out.println("Age is: "+myPerson.getAge());  
22.               
23.             oos.writeObject(myPerson);  
24.             oos.flush();  
25.             oos.close();  
26.         } catch (Exception e) {  
27.             // TODO: handle exception  
28.             e.printStackTrace();  
29.         }  
30.     }  
31.       
32.     public void restorePerson() {  
33.         try {  
34.             FileInputStream fis = new FileInputStream("E:\\workspace\\2010_03\\src\\myPerson.txt");  
35.             ObjectInputStream ois = new ObjectInputStream(fis);  
36.               
37.             Person myPerson = (Person)ois.readObject();  
38.             System.out.println("\n--------------------\n");  
39.             System.out.println("Person--Jay,24---Restored");  
40.             System.out.println("Name is: "+myPerson.getName());  
41.             System.out.println("Age is: "+myPerson.getAge());  
42.         } catch (Exception e) {  
43.             // TODO: handle exception  
44.             e.printStackTrace();  
45.         }  
46.     }  
47. }  

运行结果为（console输出），当然可以查看到myPerson.txt文件已经生成：
Inside Person's Constructor
Person--Jay,24---Written
Name is: Jay
Age is: 24


--------------------


Person--Jay,24---Restored
Name is: Jay

Age is: 24

控制对象的序列化和反序列化

前篇例子transit变量和类变量(static)不被序列化，还有种灵活的控制对象序列化和反序列方法。控制序列化就是有选择的序列化对象，不是所有内容都序列化，可储存其他非this对象包含的数据
 
接口 java.io.Externalizable 。当对象实现了这个接口时，就可以灵活的控制它的序列化和反序列过程，这个接口继承了java.io.Serializable
 
Externalizable 接口定义了两个方法，writerExternal方法在序列化时被调用，可以再该方法中控制序列化内容，readExternal方法在反序列时被调用，可以在该方法中控制反序列的内容
 

实例：UserInfo

[java]  view plain copy

1. import java.io.*;     
2. import java.util.*;     
3.     
4. //本程序通过实现Externalizable接口控制对象序列化和反序列     
5. public class UserInfo implements Externalizable {     
6.     public String userName;     
7.     public String userPass;     
8.     public int userAge;     
9.     
10.     public UserInfo(){     
11.     }     
12.     
13.     public UserInfo(String username,String userpass,int userage){     
14.         this.userName=username;     
15.         this.userPass=userpass;     
16.         this.userAge=userage;     
17.     }     
18.          
19.     //当序列化对象时,该方法自动调用     
20.     public void writeExternal(ObjectOutput out) throws IOException{     
21.         System.out.println("现在执行序列化方法");     
22.         //可以在序列化时写非自身的变量     
23.         Date d=new Date();     
24.         out.writeObject(d);     
25.         //只序列化userName,userPass变量     
26.         out.writeObject(userName);     
27.         out.writeObject(userPass);     
28.     }     
29.     
30.     //当反序列化对象时,该方法自动调用     
31.     public void readExternal(ObjectInput in) throws IOException,ClassNotFoundException{     
32.         System.out.println("现在执行反序列化方法");     
33.         Date d=(Date)in.readObject();     
34.         System.out.println(d);     
35.         this.userName=(String)in.readObject();     
36.         this.userPass=(String)in.readObject();     
37.     }     
38.     
39.     public String toString(){     
40.         return "用户名: "+this.userName+";密码："+this.userPass+     
41.             ";年龄："+this.userAge;     
42.     }     
43. }    

改写测试类

[java]  view plain copy

1. import java.io.ObjectOutputStream;     
2. import java.io.ObjectInputStream;     
3. import java.io.FileInputStream;     
4. import java.io.FileOutputStream;     
5. import java.util.Date;     
6. import java.lang.management.*;     
7. public class Test {     
8.     
9.     
10.     
11.     //序列化对象到文件     
12.     public static void serialize(String fileName){     
13.         try    
14.         {     
15.             //创建一个对象输出流，讲对象输出到文件     
16.             ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream(fileName));     
17.     
18.             UserInfo user=new UserInfo("renyanwei","888888",20);     
19.             out.writeObject(user);  //序列化一个会员对象     
20.     
21.             out.close();     
22.         }     
23.         catch (Exception x)     
24.         {     
25.             System.out.println(x.toString());     
26.         }     
27.              
28.     }     
29.     //从文件反序列化到对象     
30.     public static void deserialize(String fileName){     
31.         try    
32.         {     
33.             //创建一个对象输入流，从文件读取对象     
34.             ObjectInputStream in=new ObjectInputStream(new FileInputStream(fileName));     
35.     
36.             //读取UserInfo对象并调用它的toString()方法     
37.             UserInfo user=(UserInfo)(in.readObject());               
38.             System.out.println(user.toString());     
39.     
40.             in.close();     
41.         }     
42.         catch (Exception x)     
43.         {     
44.             System.out.println(x.toString());     
45.         }     
46.              
47.     }     
48.     
49.     public static void main(String[] args) {         
50.     
51.         serialize("D:\\test.txt");     
52.         System.out.println("序列化完毕");     
53.              
54.         deserialize("D:\\test.txt");     
55.         System.out.println("反序列化完毕");     
56.     }     
57.     
58. }    

执行结果


现在执行序列化方法
序列化完毕
现在执行反序列化方法
Thu Oct 23 22:18:12 CST 2008
用户名: renyanwei;密码：888888;年龄：0
反序列化完毕