Java之对象串行化

串行化的意义、反串行化、如何串行化、理解transient

串行化(serialization)是指将一个对象的当前状态转换成字节流(a stream of bytes)的过程，而反串行化(deserialization)则指串行化过程的逆过程，将字节流转换成一个对象，打回原形。 
一、串行化的意义： 
1：解决Web应用程序的无状态弊端 
一旦将某一对象串行化，得到的字节可以存储在文件、数据库，或内存中—— 只要是可以存储的任何地方。需要恢复对象时，仅仅只需从它存储的位置反串行化即可。对象固有的这种特性对于无状态的Web应用程序是非常重要的，因为它允许重要的状态信息可以在用户请求之间保留。 
2：应用程序边界之间传递对象 
串行化也允许对象在应用程序边界之间传递，编程人员可以将描述对象状态的字节流在网络上传递，并在另一端反串行化成一个匹配的对象。从本质上讲，串行化允许对象以“数值”的方式传递给另一个应用程序。 
二：串行化对象 
在java中串行化对象必须： 
1、该对象的类必须实现Serializable接口 
2、该对象的串行化成员必须是非静态成员变量，即不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符，都不能保存。而对于某些类型的对象，其状态是瞬时的，这样的对象是无法保存其状态的，例如一个Thread对象，或一个FileInputStream对象，对于这些字段，我们必须用transient关键字标明 。 另外 ，串行化可能涉及将对象存放到 磁盘上或在网络上发达数据，这时候就会产生安全问题。因为数据位于Java运行环境之外，不在Java安全机制的控制之中。对于这些需要保密的字段，不应保存在永久介质中 ，或者不应简单地不加处理地保存下来 ，为了保证安全性。应该在这些字段前加上transient关键字。
注：保存任何的成员方法和静态的成员变量没有任何的意义，因为，对象的类已经完整的保存了他们，如果再串行化他们还有什么意义呢？呵呵 
3、要串行化一个对象，必须与一定的对象输入/输出流联系起来，通过对象输出流将对象状态保存下来，再通过对象输入流将对象状态恢复。 
三：具体实现 
1、串行化的对象:Person类 

Java代码  

1. import java.io.Serializable;  
2. /*   
3.  * time:2008-07-19   
4.  * author:coke   
5.  */   
6.   
7. /* 
8.  *必须实现Serializable  
9.  */  
10. public class Person implements Serializable {  
11.     private static final long serialVersionUID = 1L;  
12.     private int age; // will persist  
13.     private String name; // will persist  
14.     // transient 为Java保留字，告诉JVM以transient宣告的基本型态(primitive type)或物  
15.     // 件(object)变量不要序列化，例如敏感性数据像是密码等。  
16.     private transient String pwd; // will not persist  
17.     public Person() {  
18.     }  
19.   
20.     public Person(int age, String name,String pwd) {  
21.         this.age = age;  
22.         this.name = name;  
23.         this.pwd=pwd;  
24.     }  
25.   
26.     public int getAge() {  
27.         return age;  
28.     }  
29.   
30.     public void setAge(int age) {  
31.         this.age = age;  
32.     }  
33.   
34.     public String getName() {  
35.         return name;  
36.     }  
37.   
38.     public void setName(String name) {  
39.         this.name = name;  
40.     }  
41.   
42.     public String getPwd() {  
43.         return pwd;  
44.     }  
45.   
46.     public void setPwd(String pwd) {  
47.         this.pwd = pwd;  
48.     }  
49. }  

2、串行化和反串行化 

Java代码  

1. import java.io.FileNotFoundException;  
2. import java.io.IOException;  
3. import java.io.ObjectInputStream;  
4. import java.io.ObjectOutputStream;  
5. import java.io.FileInputStream;  
6. import java.io.FileOutputStream;  
7. import java.io.File;  
8. /* 
9.  * time:2008-07-19 
10.  * author:coke 
11.  */  
12. public class TestSerializable {  
13.     private static File f = null;  
14.   
15.     //串行化  
16.     public static void serialization() {  
17.         f = new File("D://t.m");  
18.         try {  
19.             if (f.exists())  
20.                 f.delete();  
21.             f.createNewFile();  
22.   
23.         } catch (IOException e1) {  
24.             // TODO Auto-generated catch block  
25.             e1.printStackTrace();  
26.         }  
27.         Person p = new Person(10, "xplq", "123456");  
28.         try {  
29.             ObjectOutputStream out = new ObjectOutputStream(  
30.                     new FileOutputStream(f));  
31.             out.writeObject(p);  
32.         } catch (FileNotFoundException e) {  
33.             e.printStackTrace();  
34.         } catch (IOException e) {  
35.             e.printStackTrace();  
36.         }  
37.     }  
38.     //反串行化  
39.     public static void deserialization() {  
40.         if (!f.exists())  
41.             return;  
42.         try {  
43.             ObjectInputStream input = new ObjectInputStream(  
44.                     new FileInputStream(f.getPath()));  
45.             try {  
46.                 Person p = (Person) input.readObject();  
47.                 System.out.println(p.getName());  
48.                 System.out.println(p.getAge());  
49.                 System.out.println(p.getPwd());  
50.             } catch (ClassNotFoundException e) {  
51.                 // TODO Auto-generated catch block  
52.                 e.printStackTrace();  
53.             }  
54.         } catch (FileNotFoundException e) {  
55.             // TODO Auto-generated catch block  
56.             e.printStackTrace();  
57.         } catch (IOException e) {  
58.             // TODO Auto-generated catch block  
59.             e.printStackTrace();  
60.         }  
61.     }  
62.     //测试  
63.     public static void main(String[] args) {  
64.         TestSerializable.serialization();  
65.         TestSerializable.deserialization();  
66.     }  
67.   
68. }  

3.测试结果 
xplq 
10 
null 

因为pwd transient ,不能被串行化

参考：
http://www.iteye.com/topic/216504
http://qtlkw.iteye.com/blog/852459
http://www.cnblogs.com/vicenteforever/articles/1471775.html