文章目錄

簡介

你知道序列化可以使用代理嗎？你知道序列化的安全性嗎？每個java程序員都聽說過序列化，要存儲對象需要序列化，要在網絡上傳輸對象要序列化，看起來很簡單的序列化其實裏面還隱藏着很多小祕密，今天本文將會爲大家一一揭祕。

更多精彩內容且看：

更多內容請訪問www.flydean.com

什麼是序列化

序列化就是將java對象按照一定的順序組織起來，用於在網絡上傳輸或者寫入存儲中。而反序列化就是從網絡中或者存儲中讀取存儲的對象，將其轉換成爲真正的java對象。

所以序列化的目的就是爲了傳輸對象，對於一些複雜的對象，我們可以使用第三方的優秀框架，比如Thrift，Protocol Buffer等，使用起來非常的方便。

JDK本身也提供了序列化的功能。要讓一個對象可序列化，則可以實現java.io.Serializable接口。

java.io.Serializable是從JDK1.1開始就有的接口，它實際上是一個marker interface，因爲java.io.Serializable並沒有需要實現的接口。繼承java.io.Serializable就表明這個class對象是可以被序列化的。

@Data
@AllArgsConstructor
public class CustUser implements java.io.Serializable{
    private static final long serialVersionUID = -178469307574906636L;
    private String name;
    private String address;
}

上面我們定義了一個CustUser可序列化對象。這個對象有兩個屬性：name和address。

接下看下怎麼序列化和反序列化：

public void testCusUser() throws IOException, ClassNotFoundException {
        CustUser custUserA=new CustUser("jack","www.flydean.com");
        CustUser custUserB=new CustUser("mark","www.flydean.com");

        try(FileOutputStream fileOutputStream = new FileOutputStream("target/custUser.ser")){
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(custUserA);
            objectOutputStream.writeObject(custUserB);
        }
        
        try(FileInputStream fileInputStream = new FileInputStream("target/custUser.ser")){
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            CustUser custUser1 = (CustUser) objectInputStream.readObject();
            CustUser custUser2 = (CustUser) objectInputStream.readObject();
            log.info("{}",custUser1);
            log.info("{}",custUser2);
        }
    }

上面的例子中，我們實例化了兩個CustUser對象，並使用objectOutputStream將對象寫入文件中，最後使用ObjectInputStream從文件中讀取對象。

上面是最基本的使用。需要注意的是CustUser class中有一個serialVersionUID字段。

serialVersionUID是序列化對象的唯一標記，如果class中定義的serialVersionUID和序列化存儲中的serialVersionUID一致，則表明這兩個對象是一個對象，我們可以將存儲的對象反序列化。

如果我們沒有顯示的定義serialVersionUID，則JVM會自動根據class中的字段，方法等信息生成。很多時候我在看代碼的時候，發現很多人都將serialVersionUID設置爲1L，這樣做是不對的，因爲他們沒有理解serialVersionUID的真正含義。

重構序列化對象

假如我們有一個序列化的對象正在使用了，但是突然我們發現這個對象好像少了一個字段，要把他加上去，可不可以加呢？加上去之後原序列化過的對象能不能轉換成這個新的對象呢？

答案是肯定的，前提是兩個版本的serialVersionUID必須一樣。新加的字段在反序列化之後是空值。

序列化不是加密

有很多同學在使用序列化的過程中可能會這樣想，序列化已經將對象變成了二進制文件，是不是說該對象已經被加密了呢？

這其實是序列化的一個誤區，序列化並不是加密，因爲即使你序列化了，還是能從序列化之後的數據中知道你的類的結構。比如在RMI遠程調用的環境中，即使是class中的private字段也是可以從stream流中解析出來的。

如果我們想在序列化的時候對某些字段進行加密操作該怎麼辦呢？

這時候可以考慮在序列化對象中添加writeObject和readObject方法：

private String name;
    private String address;
    private int age;

    private void writeObject(ObjectOutputStream stream)
            throws IOException
    {
        //給age加密
        age = age + 2;
        log.info("age is {}", age);
        stream.defaultWriteObject();
    }

    private void readObject(ObjectInputStream stream)
            throws IOException, ClassNotFoundException
    {
        stream.defaultReadObject();
        log.info("age is {}", age);
        //給age解密
        age = age - 2;
    }

上面的例子中，我們爲CustUser添加了一個age對象,並在writeObject中對age進行了加密（加2），在readObject中對age進行了解密（減2）。

注意，writeObject和readObject都是private void的方法。他們的調用是通過反射來實現的。

使用真正的加密

上面的例子，我們只是對age字段進行了加密，如果我們想對整個對象進行加密有沒有什麼好的處理辦法呢？

JDK爲我們提供了javax.crypto.SealedObject 和java.security.SignedObject來作爲對序列化對象的封裝。從而將整個序列化對象進行了加密。

還是舉個例子：

public void testCusUserSealed() throws IOException, ClassNotFoundException, NoSuchPaddingException, NoSuchAlgorithmException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException, InvalidKeyException {
        CustUser custUserA=new CustUser("jack","www.flydean.com");
        Cipher enCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        Cipher deCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKey secretKey = new SecretKeySpec("saltkey111111111".getBytes(), "AES");
        IvParameterSpec iv = new IvParameterSpec("vectorKey1111111".getBytes());
        enCipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
        deCipher.init(Cipher.DECRYPT_MODE,secretKey,iv);
        SealedObject sealedObject= new SealedObject(custUserA, enCipher);

        try(FileOutputStream fileOutputStream = new FileOutputStream("target/custUser.ser")){
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(sealedObject);
        }

        try(FileInputStream fileInputStream = new FileInputStream("target/custUser.ser")){
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            SealedObject custUser1 = (SealedObject) objectInputStream.readObject();
            CustUser custUserV2= (CustUser) custUser1.getObject(deCipher);
            log.info("{}",custUserV2);
        }
    }

上面的例子中，我們構建了一個SealedObject對象和相應的加密解密算法。

SealedObject就像是一個代理，我們寫入和讀取的都是這個代理的加密對象。從而保證了在數據傳輸過程中的安全性。

使用代理

上面的SealedObject實際上就是一種代理，考慮這樣一種情況，如果class中的字段比較多，而這些字段都可以從其中的某一個字段中自動生成，那麼我們其實並不需要序列化所有的字段，我們只把那一個字段序列化就可以了，其他的字段可以從該字段衍生得到。

在這個案例中，我們就需要用到序列化對象的代理功能。

首先，序列化對象需要實現writeReplace方法，表示替換成真正想要寫入的對象：

public class CustUserV3 implements java.io.Serializable{

    private String name;
    private String address;

    private Object writeReplace()
            throws java.io.ObjectStreamException
    {
        log.info("writeReplace {}",this);
        return new CustUserV3Proxy(this);
    }
}

然後在Proxy對象中，需要實現readResolve方法，用於從系列化過的數據中重構序列化對象。如下所示：

public class CustUserV3Proxy implements java.io.Serializable{

    private String data;

    public CustUserV3Proxy(CustUserV3 custUserV3){
        data =custUserV3.getName()+ "," + custUserV3.getAddress();
    }

    private Object readResolve()
            throws java.io.ObjectStreamException
    {
        String[] pieces = data.split(",");
        CustUserV3 result = new CustUserV3(pieces[0], pieces[1]);
        log.info("readResolve {}",result);
        return result;
    }
}

我們看下怎麼使用：

public void testCusUserV3() throws IOException, ClassNotFoundException {
        CustUserV3 custUserA=new CustUserV3("jack","www.flydean.com");

        try(FileOutputStream fileOutputStream = new FileOutputStream("target/custUser.ser")){
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(custUserA);
        }

        try(FileInputStream fileInputStream = new FileInputStream("target/custUser.ser")){
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            CustUserV3 custUser1 = (CustUserV3) objectInputStream.readObject();
            log.info("{}",custUser1);
        }
    }

注意，我們寫入和讀出的都是CustUserV3對象。

Serializable和Externalizable的區別

最後我們講下Externalizable和Serializable的區別。Externalizable繼承自Serializable，它需要實現兩個方法：

 void writeExternal(ObjectOutput out) throws IOException;
 void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;

什麼時候需要用到writeExternal和readExternal呢？

使用Serializable，Java會自動爲類的對象和字段進行對象序列化，可能會佔用更多空間。而Externalizable則完全需要我們自己來控制如何寫/讀，比較麻煩，但是如果考慮性能的話，則可以使用Externalizable。

另外Serializable進行反序列化不需要執行構造函數。而Externalizable需要執行構造函數構造出對象，然後調用readExternal方法來填充對象。所以Externalizable的對象需要一個無參的構造函數。

總結

本文詳細分析了序列化對象在多種情況下的使用，並講解了Serializable和Externalizable的區別，希望大家能夠喜歡。

本文作者：flydean程序那些事

本文鏈接：http://www.flydean.com/java-serialization/

本文來源：flydean的博客

歡迎關注我的公衆號:程序那些事，更多精彩等着您！

你不知道的java對象序列化的祕密

文章目錄

簡介

什麼是序列化

重構序列化對象

序列化不是加密

使用真正的加密

使用代理

Serializable和Externalizable的區別

總結

linux安裝cuda和cudnn

模擬手機設備：使用 Playwright 實現移動端自動化測試

Mellanox網卡開啓SR-IOV

測試人員都是畫畫大神，讓我看看誰還不會用代碼圖？

Object.values()對象遍歷

我拍了拍Redis，被移出了羣聊···

網絡現代化通向雲原生應用的高速公路

面試官：說說你對序列化的理解

我宣佈，這是我找到的史上AI最全論文體系！

flutter系列之:創建一個內嵌的navigation 簡介搭建主Navigator 構建子路由總結

還不知道如何在java中終止一個線程?快來,一文給你揭祕簡介 Thread.stop被禁用之謎怎麼才能安全？捕獲異常之後的處理總結

flutter系列之:在flutter中自定義themes 簡介 MaterialApp中的themes 自定義themes的使用總結

flutter系列之:Navigator的高級用法簡介 named routes 給named route傳參數從Screen返回值向Screen傳值總結

flutter系列之:在flutter中使用導航Navigator 簡介 flutter中的Navigator Navigator的使用總結

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結