Java 對象的序列化、反序列化

 

對象的序列化（Serialize）：將內存中的Java對象轉換為與平台無關的二進制流（字節序列），然后存儲在磁盤文件中，或通過網絡傳輸給另一個網絡節點。

對象的反序列化（Deserialize）：獲取序列化的二進制流（不管是通過網絡，還是通過讀取磁盤文件），將之恢復為原來的Java對象。

 

 

要實現對象的序列化，該對象所屬的類必須要是可序列化的，即該類必須實現以下2個接口之一：

• Serializable     這只是一個標記接口，此接口只是表明該類是可序列化的，不用實現任何方法。Java自帶的類基本都已implement  Serializable，不用我們操心，我們自定義的類                         要實現序列化，必須要手寫implement  Serializable。
• Externalizable      用於實現自定義序列化

 

要通過網絡傳輸的Java對象、要保存到磁盤的Java對象必須要是可序列化的，不然程序會出現異常。

JavaEE的分布式應用往往要跨平台、跨網絡，通過網絡傳輸的Java對象必須要是可序列化的，HttpSession、ServletContext等Java  Web對象都已實現序列化。如果我們要通過網絡傳輸自定義的Java對象，該類（一般是JavaBean）要是可序列化的。通常建議：把所有的JavaBean都寫成是可序列化的。

 

 

ObjectOutputStream是一個處理流，提供了void  writeObject(Object  obj)方法用於對象的序列化（對象輸出流，輸出到文件/網絡）。

ObjectInputStream也是一個處理流，提供了Object  readObject()方法用於反序列化（對象輸入流，讀取文件/網絡中的對象到內存）。

 

 

示例：

//要實現Serializable接口（並不用實現任何方法）
class Student implements Serializable{
    private int id;
    private String name;
    private int age;

    public Student(int id,String name,int age){
        this.id=id;
        this.name=name;
        this.age=age;
    }

   public int getId(){
        return this.id;
   }

   public void setId(int id){
        this.id=id;
   }

   public String getName(){
        return this.name;
   }

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

   public int getAge(){
        return this.age;
   }

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

 

 //序列化
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./obj.txt"));  //處理流，要建立在節點流之上
        Student zhangsan=new Student(1,"張三",20);
        oos.writeObject(zhangsan);   //writeObject(Object obj)用於序列化一個對象（輸出到文件/網絡節點）

        //反序列化
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("./obj.txt"));
        Student student=(Student)ois.readObject();   //返回的是Object類型，所以往往要強制類型轉換

        System.out.println("學號："+student.getId());
        System.out.println("姓名："+student.getName());
        System.out.println("年齡："+student.getAge());

 

ObjectInputStream、ObjectOutputStream也包含了其他IO方法，可輸入/輸出多種類型的數據，即可以字符為單位進行操作，又可以字節為單位進行操作。

 

 

writeObject(Object  obj)一次只能寫出一個對象，可多次調用，向同一文件中寫入多個對象；

readObject()一次只能讀一個對象，讀取一個對象后，指針自動后移，指向下一個對象。讀的順序和寫的順序是一一對應的。

示例：

 //序列化，向同一文件中寫入多個對象
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./obj.txt"));  //處理流，要建立在節點流之上
        Student zhangsan=new Student(1,"張三",20);
        Student lisi=new Student(2,"李四",20);
        Student wangwu=new Student(3,"王五",20);
        oos.writeObject(zhangsan);  //張三
        oos.writeObject(lisi);  //李四
        oos.writeObject(wangwu);  //王五

        //反序列化，讀取順序和寫入順序是一致的
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("./obj.txt"));
        Student zhangsan1=(Student)ois.readObject();    //張三
        Student lisi1=(Student)ois.readObject();  //李四
        Student wangwu1=(Student)ois.readObject();  //王五

 

 

 

 

如果要序列化的類有父類（直接或者間接），那么這些父類必須要是可序列化的，或者具有無參的構造函數，否則會拋出 InvalidClassException  異常。

class Student extends People implements Serializable{
    //......
}

如果Student要序列化，則有2種方案可選：

• 其父類People也要是可序列化的（遞歸）。       這樣Student繼承自People中的成員才可以序列化輸出到文件/網絡。
• 其父類不是可序列化的，但是其父類有無參的構造函數。      這樣不會報錯，但Student繼承自People中的成員不會序列化輸出到文件/網絡。

 

 

 

 

如果該類持有其它類的引用，則引用的類都要是可序列化的，此類才是可序列化的。

class Student implements Serializable {
    private int id;
    private String name;  //Java自帶的類基本都實現了可序列化，不用管
    private int age;
    private Teacher teacher;    //此類持有一個Teacher類的引用。Teacher類必須要是可序列化的，Student類才是可序列化的。
    //......
}

 

 

 

 

 

如果要多次輸出同一個對象，則第一次輸出的是該對象的字節序列，以后每次輸出的是該對象的編號。

  ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./obj.txt"));
        Student zhangsan=new Student(1,"張三",20);

        oos.writeObject(zhangsan);   //第一次序列化這個對象，輸出此對象的字節序列。假設此對象的編號為1，編號唯一標識此對象。
        oos.writeObject(zhangsan);  //再次輸出此對象，輸出的是此對象的編號，直接輸出1。讀取此對象時讀取的仍是zhangsan這個對象。
        oos.writeObject(zhangsan);  //直接輸出1。
        //類似於c++中的指針，通過編號指向某個已存在對象。減少了重新序列化對象的時間、內存開銷。

 

如果中間修改了此對象，再次序列化此對象時，修改后的結果不會同步到文件/網絡節點中。

 ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./obj.txt"));
        Student zhangsan=new Student(1,"張三",20);

        oos.writeObject(zhangsan);   //初次序列化，輸出此對象的字節序列。假設編號為1
        zhangsan.setName("李四");   //之后修改了此對象
        oos.writeObject(zhangsan);  //再次輸出此對象，輸出的是編號1。1代表編號為1的對象。

        /*
        在此對象第一次序列化之后，對此對象做修改，后面再次輸出此對象時，都是指向第一次輸出的那個對象，做的修改並不會寫到文件/網絡節點中。
        讀取的也都是第一次輸出的那個對象。

        實際上，序列化一個對象時，JVM會先檢查在本次虛擬機中是否已序列化過這個對象，如果已序列化過，直接輸出對應的序列化編號，未序列化過才序列化。
　　　　　JVM是以對象名來區分序列化的是否是同一個對象。對象名相同，JVM就認為序列化的是同一個對象，直接輸出該對象的編號，並不判斷此對象是否修改過。
14
        修改此對象后，就算我們把此對象序列化到另一個文件中，輸出的也是此對象第一次序列化時的編號，修改並不會同步到這個文件中。
        */

 

 

 

 

 

Java9新增了過濾功能，讀取對象時，可以先檢查該對象是否滿足指定的要求，滿足才允許恢復，否則拒絕恢復。

 ObjectInputStream ois=new ObjectInputStream(new FileInputStream("obj.txt"));
        /*
        參數是一個ObjectInputFilter接口的對象，函數式接口，只需實現checkInput()方法。
        參數info是FilterInfo類的對象。

        返回值要是預定義的常量：
        Status.ALLOWED  允許恢復
        Status.REJECTED  拒絕恢復
        Status.UNDECIDED  未決定，將繼續執行檢查
         */
        ois.setObjectInputFilter((info)->{
            ObjectInputFilter serialFilter=ObjectInputFilter.Config.getSerialFilter();   //獲取默認的輸入過濾器
            if(serialFilter!=null){
                //先使用默認的過濾器進行檢查
                ObjectInputFilter.Status status=serialFilter.checkInput(info);
                //如果已知道結果
                if (status!= ObjectInputFilter.Status.UNDECIDED)
                    return status;
            }
            //執行到此，就說明結果是Status.UNDECIDED，還不知道結果，要繼續檢查
            //如果引用不唯一，說明數據被污染了，不允許恢復
            if(info.references()!=1)
                return ObjectInputFilter.Status.REJECTED;
            //是指定的類的對象（Student)，才允許恢復（執行反序列化)
            if(info.serialClass()!=null && info.serialClass() != Student.class)
                return ObjectInputFilter.Status.ALLOWED;
            //執行到此，說明不是指定類的對象，不允許恢復。
            return ObjectInputFilter.Status.REJECTED;
        });
        //這樣恢復的對象都是唯一的Student對象
        //...........