java的序列化机制(一)

    好久没有写博客了，前几天陆续的把草稿箱里的文章发出来，这篇也是比较早了，说来惭愧

说到序列化，容易跟一个词搞混“持久化”，在很长的一段时间内我也曾将序列化和持久化的概念弄混淆，那什么是持久化还有序列化呢。

1）持久（Persistence），即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的数据存储在关系型的数据库中，当然也可以存储在磁盘文件中、XML数据文件等。对象持久化的重点在于如何将业务数据对象存储在持久化介质上，并同时提供查询修改的手段。

2）什么是序列化

        简单说就是为了保存在内存中的各种对象的状态，并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存Object States，但是Java给你提供一种应该比你自己好的保存对象状态的机制,那就是序列化。

        Java序列化技术可以使你将一个对象的状态写入一个Byte 流里，并且可以从其它地方把该Byte 流里的数据读出来，重新构造一个相同的对象。这种机制允许你将对象通过网络进行传播，并可以随时把对象持久化到数据库、文件等系统里。Java的串行化机制是RMI、EJB等技术的技术基础。用途：利用对象的序列化实现保存应用程序的当前工作状态，下次再启动的时候将自动地恢复到上次执行的状态，在分布式环境中可能需要将Object从这一端网络或设备传递到另一端。Java序列化API提供一种处理对象序列化的标准机制。

        二：序列化的实现

一个对象能够序列化的前提是实现Serializable接口，Serializable接口没有方法，更像是个标记。有了这个标记的Class就能被序列化机制处理。

对象的默认序列化机制：序列化时，对象的类、类的签名，以及类及其所有超类型的非瞬态(non-transient)和非静态(non-static)字段的值都将被写入。逆序列化时，对象的类、类的签名，以及类及其所有超类型的非瞬态(non-transient)的对象都将被读取。如果我们想某个成员变量不被序列化，可以在其前面加入transient关键字

import java.io.Serializable;

/**
 * 实现一个可以被序列话的类
 */
public class Person implements Serializable {
	/** 姓名*/
    public String name;
    /** 性别*/
    public String sex;
    /** 年龄*/
    public int age;
    /**静态变量*/
    public static String test1;
    /**如果用transient声明一个实例变量，当对象存储时，它的值不需要维持*/
    public transient String test2;
    /**构造器*/
    public Person(String name,String sex,int age) {
    	System.out.println("构造器");
    	this.name=name;
    	this.sex=sex;
    	this.age=age;
    	Person.test1=this.name;
    	this.test2=this.sex;
    }

}

再写一个测试类

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;


public class Test
{
    public static void main(String[] args)
    {
    	Person per=new Person("CSDN", "男", 11);
        try
        {
        	//序列化该对象
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("c:\\a.data"));
            out.writeObject(per);
            out.flush();
            out.close();
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
        try
        {
        	//反序列化对象
            ObjectInputStream in = new ObjectInputStream( new FileInputStream("c:\\a.data"));
            per = (Person) in.readObject();
            in.close();
        }
        catch (Exception e)
        {
        	e.printStackTrace();
        }
        Test test=new Test();
        test.printObj(per);
    }
    /**
	 * 打印对象
	 */
	public void printObj(Object obj){
		try {
			Class cla=obj.getClass();
			Field[] fields=cla.getDeclaredFields();
			StringBuffer sb=new StringBuffer("{");
			for(Field field:fields){
				sb.append(field.getName()+"="+field.get(obj)).append(",");
			}
			sb.append("}");
			System.out.println(sb);
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

观察到输出的结果是：

构造器
{name=CSDN,sex=男,age=11,test1=CSDN,test2=null,}

发现变量修饰符为transient的变量没有被读取到，当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，然而非transient型的变量是被包括进去的。