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 ,不能被串行化
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值