面試官：三年工作經(jīng)驗，你連序列化都說不明白？

什么是序列化、反序列化

• 序列化：把Java對象轉(zhuǎn)換為字節(jié)序列的過程。

• 反序列化：把字節(jié)序列恢復(fù)為Java對象的過程。

序列化的作用

• 1、可以把對象的字節(jié)序列永久地保存到硬盤上，通常存放在一個文件中；（持久化對象）

• 2、也可以在網(wǎng)絡(luò)上傳輸對象的字節(jié)序列；（網(wǎng)絡(luò)傳輸對象）

序列化在Java中的用法

在Java中序列化的實現(xiàn)：將需要被序列化的類實現(xiàn)Serializable接口，該接口沒有需要實現(xiàn)的方法，實現(xiàn)該接口只是為了標(biāo)注該對象是可被序列化的，然后使用一個輸出流(如：FileOutputStream)來構(gòu)造一個ObjectOutputStream(對象輸出流)對象，接著，使用ObjectOutputStream對象的writeObject(Object obj)方法就可以將參數(shù)為obj的對象寫出(即保存其狀態(tài))，要恢復(fù)的話則用ObjectInputStream(對象輸入流)。

如下為序列化、反序列化簡單案例 Test01：

 java.io.FileInputStream;
 java.io.FileOutputStream;
 java.io.IOException;
 java.io.ObjectInputStream;
 java.io.ObjectOutputStream;
 java.io.Serializable;

 {
    {
        
        serializable();
        
        deserialization();
    }

    {
         (ObjectOutputStream oos = ObjectOutputStream( FileOutputStream())) {
            Person person = Person();
            person.setName();
            person.setAge();
            oos.writeObject(person);
        } (IOException e) {
            e.printStackTrace();
        }
    }

    {
         (ObjectInputStream ois = ObjectInputStream( FileInputStream())) {
            Person person = (Person) ois.readObject();
            System.out.println(person);
        } (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}


{
        serialVersionUID = -;
     String name;
      age;

    {
         name;
    }

    {
        .name = name;
    }

    {
         age;
    }

    {
        .age = age;
    }

    
    {
          +
                 + name + +
                 + age +
                ;
    }
}

上面案例中只是簡單的進行了對象序列化和反序列化，但是序列化和反序列化過程中有很多值得思考的細(xì)節(jié)問題，例如：

1、序列化版本號（serialVersionUID）問題
2、靜態(tài)變量序列化
3、父類的序列化與 transient 關(guān)鍵字
4、自定義序列化規(guī)則
5、序列化存儲規(guī)則

1、序列化版本號（serialVersionUID）問題

在寫Java程序中有時我們經(jīng)常會看到類中會有一個序列化版本號：serialVersionUID。這個值有的類是1L或者是自動生成的。

private static final long serialVersionUID = 1L;

或者

private static final long serialVersionUID = -2052381772192998351L;

當(dāng)在反序列化時JVM需要判斷需要轉(zhuǎn)化的兩個類是不是同一個類，于是就需要一個序列化版本號。如果在反序列化的時候兩個類的serialVersionUID不一樣則JVM會拋出java.io.InvalidClassException的異常；如果serialVersionUID一致則表明可以轉(zhuǎn)換。

如果可序列化類未顯式聲明 serialVersionUID，則序列化運行時將基于該類的各個方面計算該類的默認(rèn) serialVersionUID 值。不過，強烈建議 所有可序列化類都顯式聲明 serialVersionUID 值，原因是計算默認(rèn)的 serialVersionUID 對類的詳細(xì)信息具有較高的敏感性，根據(jù)編譯器實現(xiàn)的不同可能千差萬別，這樣在反序列化過程中可能會導(dǎo)致意外的 InvalidClassException，所以這種方式不支持反序列化重構(gòu)。所謂重構(gòu)就是可以對類增加或者減少屬性字段，也就是說即使兩個類并不完全一致，他們也是可以轉(zhuǎn)換的，只不過如果找不到對應(yīng)的字段，它的值會被設(shè)為默認(rèn)值。

因此，為保證 serialVersionUID 值跨不同 java 編譯器實現(xiàn)的一致性或代碼重構(gòu)時，序列化類必須聲明一個明確的 serialVersionUID 值。還強烈建議使用 private 修飾符顯示聲明 serialVersionUID（如果可能），原因是這種聲明僅應(yīng)用于直接聲明類 -- serialVersionUID 字段作為繼承成員沒有用處。數(shù)組類不能聲明一個明確的 serialVersionUID，因此它們總是具有默認(rèn)的計算值，但是數(shù)組類沒有匹配 serialVersionUID 值的要求。

還有一個常見的值是1L（或者其他固定值），如果所有類都這么寫那還怎么區(qū)分它們，這個字段還有什么意義嗎？有的！首先如果兩個類有了相同的反序列化版本號，比如1L，那么表明這兩個類是支持在反序列化時重構(gòu)的。但是會有一個明顯的問題：如果兩個類是完全不同的，但是他們的序列化版本號都是1L，那么對于JVM來說他們也是可以進行反序列化重構(gòu)的！這這顯然是不對的，但是回過頭來說這種明顯的，愚蠢的錯誤在實際開發(fā)中是不太可能會犯的，如果不是那么嚴(yán)謹(jǐn)?shù)脑捰?L是個不錯的選擇。

一般的情況下這個值是顯式地指定為一個64位的哈希字段，比如你寫了一個類實現(xiàn)了java.io.Serializable接口，在idea里會提示你加上這個序列化id。這樣做可以區(qū)分不同的類，也支持反序列化重構(gòu)。

總結(jié)如下:

serialVersionUID區(qū)分不同類支持相同類的重構(gòu)

簡單而言，從嚴(yán)謹(jǐn)性的角度來說，指定64位哈希值>默認(rèn)值1L>不指定serialVersionUID值，具體怎么使用就看你的需求了。

2、靜態(tài)變量序列化

 java.io.FileInputStream;
 java.io.FileOutputStream;
 java.io.IOException;
 java.io.ObjectInputStream;
 java.io.ObjectOutputStream;
 java.io.Serializable;

 {
    {
         (ObjectOutputStream oos = ObjectOutputStream( FileOutputStream());
             ObjectInputStream ois = ObjectInputStream( FileInputStream())) {
            
            Person person = Person();
            person.setName();
            person.setAge();
            oos.writeObject(person);

            
            Person.avgAge =;

            Person person1 = (Person) ois.readObject();
            
            System.out.println(person1.avgAge);
        } (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}


{
        serialVersionUID = -;
     String name;
      age;
       avgAge =;

    {
         name;
    }

    {
        .name = name;
    }

    {
         age;
    }

    {
        .age = age;
    }

    
    {
          +
                 + name + +
                 + age +
                ;
    }
}

執(zhí)行結(jié)果顯示如下：

我們看到 Test02.java將對象序列化后，修改靜態(tài)變量的數(shù)值再將序列化對象讀取出來，然后通過讀取出來的對象獲得靜態(tài)變量的數(shù)值并打印出來，最后的輸出是 10，之所以打印 10 的原因在于序列化時，并不保存靜態(tài)變量，這其實比較容易理解，序列化保存的是對象的狀態(tài)，靜態(tài)變量屬于類的狀態(tài)，因此 序列化并不保存靜態(tài)變量 。

3、父類的序列化與 transient關(guān)鍵字

情境 ：一個子類實現(xiàn)了 Serializable 接口，它的父類都沒有實現(xiàn) Serializable 接口，序列化該子類對象，然后反序列化后輸出父類定義的某變量的數(shù)值，該變量數(shù)值與序列化時的數(shù)值不同。

解決 ：要想將父類對象也序列化，就需要讓父類也實現(xiàn) Serializable 接口 。如果父類不實現(xiàn)的話的，就需要有默認(rèn)的無參的構(gòu)造函數(shù) 。在父類沒有實現(xiàn) Serializable 接口時，虛擬機是不會序列化父對象的，而一個 Java 對象的構(gòu)造必須先有父對象，才有子對象，反序列化也不例外。所以反序列化時，為了構(gòu)造父對象，只能調(diào)用父類的無參構(gòu)造函數(shù)作為默認(rèn)的父對象。因此當(dāng)我們?nèi)「笇ο蟮淖兞恐禃r，它的值是調(diào)用父類無參構(gòu)造函數(shù)后的值。如果你考慮到這種序列化的情況，在父類無參構(gòu)造函數(shù)中對變量進行初始化，否則的話，父類變量值都是默認(rèn)聲明的值，如 int 型的默認(rèn)是 0，string 型的默認(rèn)是 null。

transient 關(guān)鍵字的作用是控制變量的序列化，在變量聲明前加上該關(guān)鍵字，可以阻止該變量被序列化到文件中，在被反序列化后，transient 變量的值被設(shè)為初始值，如 int 型的是 0，對象型的是 null。

3-1、特性使用案例：

我們熟悉使用 transient 關(guān)鍵字可以使得字段不被序列化，那么還有別的方法嗎？根據(jù)父類對象序列化的規(guī)則，我們可以將不需要被序列化的字段抽取出來放到父類中，子類實現(xiàn) Serializable 接口，父類不實現(xiàn)，根據(jù)父類序列化規(guī)則，父類的字段數(shù)據(jù)將不被序列化，形成類圖如下圖所示。

上圖中可以看出，attr1、attr2、attr3、attr5 都不會被序列化，放在父類中的好處在于當(dāng)有另外一個 Child 類時，attr1、attr2、attr3 依然不會被序列化，不用重復(fù)書寫 transient 關(guān)鍵字，代碼簡潔。

4、自定義序列化規(guī)則

在序列化和反序列化過程中需要特殊處理的類必須使用下列準(zhǔn)確簽名來實現(xiàn)特殊方法：

;
;
;

writeObject 方法負(fù)責(zé)寫入特定類的對象的狀態(tài)，以便相應(yīng)的 readObject 方法可以恢復(fù)它。通過調(diào)用 oos.defaultWriteObject 可以調(diào)用保存 Object 的字段的默認(rèn)機制。該方法本身不需要涉及屬于其超類或子類的狀態(tài)。通過使用 writeObject 方法或使用 DataOutput 支持的用于基本數(shù)據(jù)類型的方法將各個字段寫入 ObjectOutputStream，狀態(tài)可以被保存。

readObject 方法負(fù)責(zé)從流中讀取并恢復(fù)類字段。它可以調(diào)用 oin.defaultReadObject 來調(diào)用默認(rèn)機制，以恢復(fù)對象的非靜態(tài)和非瞬態(tài)(非 transient 修飾)字段。defaultReadObject方法使用流來分配保存在流中的對象的字段當(dāng)前對象中相應(yīng)命名的字段。這用于處理類演化后需要添加新字段的情形。該方法本身不需要涉及屬于其超類或子類的狀態(tài)。通過使用 writeObject 方法或使用 DataOutput 支持的用于基本數(shù)據(jù)類型的方法將各個字段寫入 ObjectOutputStream，狀態(tài)可以被保存。

在序列化流不列出給定類作為將被反序列化對象的超類的情況下，readObjectNoData 方法負(fù)責(zé)初始化特定類的對象狀態(tài)。這在接收方使用的反序列化實例類的版本不同于發(fā)送方，并且接收者版本擴展的類不是發(fā)送者版本擴展的類時發(fā)生。在序列化流已經(jīng)被篡改時也將發(fā)生；因此，不管源流是“敵意的”還是不完整的，readObjectNoData 方法都可以用來正確地初始化反序列化的對象。

readObjectNoData()應(yīng)用示例：

 java.io.FileOutputStream;
 java.io.ObjectOutputStream;
 java.io.Serializable;


 {
    {
         (ObjectOutputStream oos = ObjectOutputStream( FileOutputStream())) {
            Person person = Person();
            person.setAge();
            oos.writeObject(person);
        } (Exception e) {
            e.printStackTrace();
        }
    }
}

{
      age;

    {
        .age = age;
    }

    {
         .age;
    }
}

 java.io.FileInputStream;
 java.io.ObjectInputStream;
 java.io.Serializable;


 {
    {
         (ObjectInputStream ois = ObjectInputStream( FileInputStream())) {
            Person person = (Person) ois.readObject();
            System.out.println(person.getName());
        } (Exception e) {
            e.printStackTrace();
        }
    }
}



{
      age;

    {
        .age = age;
    }

    {
         .age;
    }
}

{
     String name;

    {
        .name = name;
    }

    {
         .name;
    }

    {
        .name =;
    }
}

將對象寫入流時需要指定要使用的替代對象的可序列化類，應(yīng)使用準(zhǔn)確的簽名來實現(xiàn)此特殊方法：

ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;

此 writeReplace 方法將由序列化調(diào)用，前提是如果此方法存在，而且它可以通過被序列化對象的類中定義的一個方法訪問。因此，該方法可以擁有私有 (private)、受保護的 (protected) 和包私有 (package-private) 訪問。子類對此方法的訪問遵循 java 訪問規(guī)則。

在從流中讀取類的一個實例時需要指定替代的類應(yīng)使用的準(zhǔn)確簽名來實現(xiàn)此特殊方法。

ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

此 readResolve 方法遵循與 writeReplace 相同的調(diào)用規(guī)則和訪問規(guī)則。

TIP： readResolve常用來反序列單例類，保證單例類的唯一性

例如：

 java.io.FileInputStream;
 java.io.FileOutputStream;
 java.io.IOException;
 java.io.ObjectInputStream;
 java.io.ObjectOutputStream;
 java.io.Serializable;

 {
    {
         (ObjectOutputStream oos = ObjectOutputStream( FileOutputStream())) {
            oos.writeObject(Brand.NIKE);
        }
         (ObjectInputStream ois = ObjectInputStream( FileInputStream())) {
            Brand b = (Brand) ois.readObject();
            
            System.out.println(b == Brand.NIKE);
        }
    }
}

{
      val;

    {
        .val = val;
    }

    
       Brand NIKE = Brand();
       Brand ADDIDAS = Brand();
}

答案很顯然是false，因為Brand.NIKE是程序中創(chuàng)建的對象，而b是從磁盤中讀取并恢復(fù)過來的對象，兩者明顯來源不同，因此必然內(nèi)存空間是不同的，引用（地址）顯然也是不同的；

但這不是我們想看到的，因為我們把Brand設(shè)計成枚舉類型，不管是程序中創(chuàng)建的還是從哪里讀取的，其必須應(yīng)該和枚舉常量完全相等，這才是枚舉的意義??！

而此時readResolve就派上用場了，我們可以這樣實現(xiàn)readResolve:

 java.io.FileInputStream;
 java.io.FileOutputStream;
 java.io.IOException;
 java.io.ObjectInputStream;
 java.io.ObjectOutputStream;
 java.io.ObjectStreamException;
 java.io.Serializable;

 {
    {
         (ObjectOutputStream oos = ObjectOutputStream( FileOutputStream())) {
            oos.writeObject(Brand.NIKE);
        }
         (ObjectInputStream ois = ObjectInputStream( FileInputStream())) {
            Brand b = (Brand) ois.readObject();
            
            System.out.println(b == Brand.NIKE);
        }
    }
}

{
      val;

    {
        .val = val;
    }

    
       Brand NIKE = Brand();
       Brand ADDIDAS = Brand();

    {
         (val ==) {
             NIKE;
        }
         (val ==) {
             ADDIDAS;
        }
         ;
    }
}

改造以后，不管來源如何，最終得到的都將是程序中Brand的枚舉值了！因為readResolve的代碼在執(zhí)行時已經(jīng)進入了程序內(nèi)存環(huán)境，因此其返回的NIKE和ADDIDAS都將是Brand的靜態(tài)成員對象；

因此保護性恢復(fù)的含義就在此：首先恢復(fù)的時候沒有改變其值（val的值沒有改變）同時恢復(fù)的時候又能正常實現(xiàn)枚舉值的對比（地址也完全相同）；

4-1、對敏感字段加密

情境：服務(wù)器端給客戶端發(fā)送序列化對象數(shù)據(jù)，對象中有一些數(shù)據(jù)是敏感的，比如密碼字符串等，希望對該密碼字段在序列化時，進行加密，而客戶端如果擁有解密的密鑰，只有在客戶端進行反序列化時，才可以對密碼進行讀取，這樣可以一定程度保證序列化對象的數(shù)據(jù)安全。

解決：在序列化過程中，虛擬機會試圖調(diào)用對象類里的 writeObject 和 readObject 方法，進行用戶自定義的序列化和反序列化，該方法必須要被聲明為private，如果沒有這樣的方法，則默認(rèn)調(diào)用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。用戶自定義的 writeObject 和 readObject 方法可以允許用戶控制序列化的過程，比如可以在序列化的過程中動態(tài)改變序列化的數(shù)值?；谶@個原理，可以在實際應(yīng)用中得到使用，用于敏感字段的加密工作，如下代碼展示了這個過程。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

   {
    {
         (ObjectOutputStream oos = ObjectOutputStream( FileOutputStream());
             ObjectInputStream ois = ObjectInputStream( FileInputStream())) {
            oos.writeObject( Account());

            Account account = (Account) ois.readObject();
            System..println( + account.getPassword());
        } (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

    {
     String password =;

    {
         password;
    }

    {
        .password = password;
    }

    {
         {
            ObjectOutputStream.PutField putFields =.putFields();
            System..println( + password);
            
            password =;
            putFields.put(, password);
            System..println( + password);
            .writeFields();
        } (IOException e) {
            e.printStackTrace();
        }
    }

    {
         {
            ObjectInputStream.GetField readFields =.readFields();
            Object = readFields.(,);
            System..println( +.toString());
            
            password =;
        } (IOException e) {
            e.printStackTrace();
        } (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

上述代碼中的 writeObject 方法中，對密碼進行了加密，在 readObject 中則對 password 進行解密，只有擁有密鑰的客戶端，才可以正確的解析出密碼，確保了數(shù)據(jù)的安全。

4-2、序列化SDK中不可序列化的類型

4-1、對敏感字段加密案例使用 writeObject 和 readObject 進行了對象屬性值加解密操作，有時我們想將對象中的某一字段序列化，但它在SDK中的定義卻是不可序列化的類型，這樣的話我們也必須把他標(biāo)注為 transient 才能保證正常序列化，可是不能序列化又怎么恢復(fù)呢？這就用到了上面提到的 writeObject 和 readObject 方法，進行自定義序列化操作了。

示例：java.awt.geom包中的Point2D.Double類就是不可序列化的，因為該類沒有實現(xiàn)Serializable接口

 java.awt.geom.Point2D;
 java.io.FileInputStream;
 java.io.FileOutputStream;
 java.io.IOException;
 java.io.ObjectInputStream;
 java.io.ObjectOutputStream;
 java.io.Serializable;

 {
    {
        LabeledPoint label = LabeledPoint(,,);
         {
            
            System.out.println(label);
            ObjectOutputStream out = ObjectOutputStream( FileOutputStream());
            
            out.writeObject(label);
            out.close();
            
            System.out.println(label);
            ObjectInputStream in = ObjectInputStream( FileInputStream());
            LabeledPoint label1 = (LabeledPoint) in.readObject();
            in.close();
            
            System.out.println(label1);
        } (Exception e) {
            e.printStackTrace();
        }
    }
}

{
     String label;
    
      Point2D.Double point;

    {
        label = str;
        
        point = Point2D.Double(x, y);
    }

    
    {
        oos.defaultWriteObject();
        oos.writeDouble(point.getX());
        oos.writeDouble(point.getY());
    }

    {
        ois.defaultReadObject();
         x = ois.readDouble() +;
         y = ois.readDouble() +;
        point = Point2D.Double(x, y);
    }

    
    {
          +
                 + label + +
                 + point +
                ;
    }
}

在 4-1、序列化SDK中不可序列化的類型案例中，你會發(fā)現(xiàn)調(diào)用了defaultWriteObject()和defaultReadObject()。它們做的是默認(rèn)的序列化進程，就像寫/讀所有的non-transient和 non-static字段(但他們不會去做serialVersionUID的檢查)。通常說來，所有我們想要自己處理的字段都應(yīng)該聲明為transient。這樣的話 defaultWriteObject/defaultReadObject 便可以專注于其余字段，而我們則可為這些特定的字段(指transient)定制序列化。使用那兩個默認(rèn)的方法并不是強制的，而是給予了處理復(fù)雜應(yīng)用時更多的靈活性。

5、序列化存儲規(guī)則

5-1、存儲兩次相同對象

 java.io.File;
 java.io.FileInputStream;
 java.io.FileOutputStream;
 java.io.IOException;
 java.io.ObjectInputStream;
 java.io.ObjectOutputStream;
 java.io.Serializable;

 {
    {
         (ObjectOutputStream oos = ObjectOutputStream( FileOutputStream());
             ObjectInputStream ois = ObjectInputStream( FileInputStream())) {
            
            Account account = Account();
            account.setPassword();
            oos.writeObject(account);
            oos.flush();
            System.out.println( File().length());
            oos.writeObject(account);
            System.out.println( File().length());

            
            Account account1 = (Account) ois.readObject();
            Account account2 = (Account) ois.readObject();

            
            System.out.println(account1 == account2);
        } (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

{
     String password;

    {
         password;
    }

    {
        .password = password;
    }
}

上述代碼中對同一對象兩次寫入文件，打印出寫入一次對象后的存儲大小和寫入兩次后的存儲大小，然后從文件中反序列化出兩個對象，比較這兩個對象是否為同一對象。一般的思維是，兩次寫入對象，文件大小會變?yōu)閮杀兜拇笮?，反序列化時，由于從文件讀取，生成了兩個對象，判斷相等時應(yīng)該是輸入 false 才對，但

我們看到，第二次寫入對象時文件只增加了 5 字節(jié)，并且兩個對象是相等的，因為Java 序列化機制為了節(jié)省磁盤空間，具有特定的存儲規(guī)則，當(dāng)寫入文件的為同一對象時，并不會再將對象的內(nèi)容進行存儲，而只是再次存儲一份引用，上面增加的 5 字節(jié)的存儲空間就是新增引用和一些控制信息的空間。反序列化時，恢復(fù)引用關(guān)系，使得上述代碼中的 account1 和 account2 指向唯一的對象，二者相等，輸出 true。該存儲規(guī)則極大的節(jié)省了存儲空間

5-2、存儲兩次相同對象，更改屬性值

 java.io.FileInputStream;
 java.io.FileOutputStream;
 java.io.IOException;
 java.io.ObjectInputStream;
 java.io.ObjectOutputStream;
 java.io.Serializable;

 {
    {
         (ObjectOutputStream oos = ObjectOutputStream( FileOutputStream());
             ObjectInputStream ois = ObjectInputStream( FileInputStream())) {
            Account account = Account();
            account.setPassword();
            oos.writeObject(account);
            oos.flush();
            account.setPassword();
            oos.writeObject(account);

            
            Account account1 = (Account) ois.readObject();
            Account account2 = (Account) ois.readObject();

            System.out.println(account1.getPassword());
            System.out.println(account2.getPassword());
        } (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

{
     String password;

    {
         password;
    }

    {
        .password = password;
    }
}

上述代碼的目的是希望將 account 對象兩次保存到 object.txt 文件中，寫入一次以后修改對象屬性值再次保存第二次，然后從 object.txt 中再依次讀出兩個對象，輸出這兩個對象的 password 屬性值。上述代碼的目的原本是希望一次性傳輸對象修改前后的狀態(tài)。

結(jié)果兩個輸出的都是 123456， 原因就是第一次寫入對象以后，第二次再試圖寫的時候，虛擬機根據(jù)引用關(guān)系知道已經(jīng)有一個相同對象已經(jīng)寫入文件，因此只保存第二次寫的引用，所以讀取時，都是第一次保存的對象。這也驗證了 5-1、存儲兩次相同對象案例的現(xiàn)象，相同對象存在只會存儲引用，不再進行對象存儲，所以第二次修改的屬性未變化。讀者在使用一個文件多次 writeObject 需要特別注意這個問題。