2.对象的串行化(Serialization)和反串行化(deserialization)

引用

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

三：具体实现
1、串行化的对象:Person类

Java代码  

    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代码  收藏代码

    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 ,不能被串行化