Java串行化问题

串行化(serialization)是指将一个对象的当前状态转换成字节流(a stream of bytes)的过程，而反串行化(deserialization)则指串行化过程的逆过程，将字节流转换成一个对象， 打回原形。
一、串行化的意义：
1：解决Web应用程序的无状态弊端
一旦将某一对象串行化，得到的字节可以存储在文件、数据库，或内存中—— 只要是可以存储的任何地方。需要恢复对象时，仅仅只需从它存储的位置反串行化即可。对象固有的这种特性对于无状态的Web应用程序是非常重要的，因为它允许重要的状态信息可以在用户请求之间保留。
2：应用程序边界之间传递对象
串行化也允许对象在应用程序边界之间传递，编程人员可以将描述对象状态的字节流在网络上传递，并在另一端反串行化成一个匹配的对象。从本质上讲，串行化允许对象以“数值”的方式传递给另一个应用程序。
二：串行化对象
在java中串行化对象必须：
1、该对象的类必须实现Serializable接口
2、该对象的串行化成员必须是非静态成员变量，即不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符，都不能保存。而对于某些类型的对象，其状态是瞬时的，这样的对象是无法保存其状态的，例如一个Thread对象，或一个FileInputStream对象，对于这些字段，我们必须用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. }  

import java.io.Serializable;
/*  
 * time:2008-07-19  
 * author:coke  
 */ 

/*
 *必须实现Serializable 
 */
public class Person implements Serializable {
	private static final long serialVersionUID = 1L;
	private int age; // will persist
	private String name; // will persist
	// transient 为Java保留字，告诉JVM以transient宣告的基本型态(primitive type)或物
	// 件(object)变量不要序列化，例如敏感性数据像是密码等。
	private transient String pwd; // will not persist
	public Person() {
	}

	public Person(int age, String name,String pwd) {
		this.age = age;
		this.name = name;
		this.pwd=pwd;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPwd() {
		return pwd;
	}

	public void setPwd(String pwd) {
		this.pwd = pwd;
	}
}

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. }  

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.File;
/*
 * time:2008-07-19
 * author:coke
 */
public class TestSerializable {
	private static File f = null;

	//串行化
	public static void serialization() {
		f = new File("D://t.m");
		try {
			if (f.exists())
				f.delete();
			f.createNewFile();

		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		Person p = new Person(10, "xplq", "123456");
		try {
			ObjectOutputStream out = new ObjectOutputStream(
					new FileOutputStream(f));
			out.writeObject(p);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	//反串行化
	public static void deserialization() {
		if (!f.exists())
			return;
		try {
			ObjectInputStream input = new ObjectInputStream(
					new FileInputStream(f.getPath()));
			try {
				Person p = (Person) input.readObject();
				System.out.println(p.getName());
				System.out.println(p.getAge());
				System.out.println(p.getPwd());
			} catch (ClassNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	//测试
	public static void main(String[] args) {
		TestSerializable.serialization();
		TestSerializable.deserialization();
	}

}

3.测试结果
xplq
10
null
因为pwd transient ,不能被串行化