面試題：Java序列化與反序列化-有解無憂

序列化和反序列化的概念
應用場景？
序列化實作的方式
- 繼承Serializable介面，普通序列化
- 繼承Externalizable介面，強制自定義序列化
serialVersionUID的作用
靜態變數不會被序列化
使用序列化實作深拷貝
常見序列化協議對比
小結

作者：小牛呼嚕嚕 | https://xiaoniuhululu.com
計算機內功、JAVA底層、面試相關資料等更多精彩文章在公眾號「小牛呼嚕嚕」

序列化和反序列化的概念

當我們在Java中創建物件的時候，物件會一直存在，直到程式終止時，但有時候可能存在一種"持久化"場景：我們需要讓物件能夠在程式不運行的情況下，仍能存在并保存其資訊，當程式再次運行時還可以通過該物件的保存下來的資訊來重建該物件，序列化和反序列化就應運而生了，序列化機制可以使物件可以脫離程式的運行而獨立存在，

序列化：將物件轉換成二進制位元組流的程序
反序列化：從二進制位元組流中恢復物件的程序

應用場景？

物件在進行網路傳輸的時候，需要先被序列化，接收到序列化的物件之后需要再進行反序列化；比如遠程方法呼叫 RPC
將物件存盤到檔案中的時候需要進行序列化，將物件從檔案中讀取出來需要進行反序列化，
將物件存盤到記憶體中，需要進行序列化，將物件從記憶體中讀取出來需要進行反序列化，
將物件存盤到資料庫（如 Redis）時，需要用到序列化，將物件從快取資料庫中讀取出來需要反序列化，

序列化實作的方式

如果使用Jdk自帶的序列化方式實作物件序列化的話，那么這個類應該實作Serializable介面或者Externalizable介面

繼承Serializable介面，普通序列化

首先我們定義一個物件類User

public class User implements Serializable {
    //序列化ID
    private static final long serialVersionUID = 1L;
    private int age;
    private String name;

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

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    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 class serTest {
    public static void main(String[] args) throws Exception, IOException {
        SerializeUser();
        DeSerializeUser();
    }

    /**
     * 序列化方法
     * @throws IOException
     */
    private static void SerializeUser() throws  IOException {
        User user = new User(11, "小張");

        //序列化物件到指定的檔案中
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\jun\\Desktop\\example"));
        oos.writeObject(user);
        oos.close();
        System.out.println("序列化物件成功");
    }

    /**
     * 反序列化方法
     * @throws IOException
     * @throws ClassNotFoundException
     */
    private static void DeSerializeUser() throws  IOException, ClassNotFoundException {
        //讀取指定的檔案
        File file = new File("C:\\Users\\jun\\Desktop\\example");
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        User newUser = (User)ois.readObject();
        System.out.println("反序列化物件成功:"+ newUser.getName()+ ","+newUser.getAge());
    }
}

結果：

序列化物件成功
反序列化物件成功:小張,11

一個物件想要被序列化，那么它的類就要繼承Serializable介面或者它的子介面

繼承Serializable介面類的所有屬性（包括private屬性、包括其參考的物件）都可以被序列化和反序列化來保存、傳遞，如果不想序列化的欄位可以使用transient關鍵字修飾

private int age;
private String name;
private transient password;//屬性：密碼，不想被序列化

我們需要注意的是：使用transient關鍵字阻止序列化雖然簡單方便，但被它修飾的屬性被完全隔離在序列化機制之外，這必然會導致了在反序列化時無法獲取該屬性的值，
其實我們完全可以在通過在需要序列化的物件的Java類里加入writeObject()方法與readObject()方法來控制如何序列化各屬性，某些屬性是否被序列化

如果User有一個屬性是參考型別的呢？比如User其中有一個屬性是類Person:

private Person person;

那如果要想User可以序列化，那Person類也必須得繼承Serializable介面，不然程式會報錯

另外大家應該注意到serialVersionUID了吧，在日常開發的程序中，經常遇到，暫且放放，我們后文再詳細講解

繼承Externalizable介面，強制自定義序列化

對于Externalizable介面，我們需要知道以下幾點：

Externalizable繼承自Serializable介面
需要我們重寫writeExternal()與readExternal()方法，這是強制性的
實作Externalizable介面的類必須要提供一個public的無參的構造器，因為反序列化的時候需要反射創建物件
Externalizable介面實作序列化，性能稍微比繼承自Serializable介面好一點

首先我們定義一個物件類ExUser

public class ExUser implements Externalizable {
    private int age;
    private String name;

    //注意，必須加上pulic 無參構造器
    public ExUser() {
    }

    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;
    }
    
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeInt(age);
    }
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.name = (String)in.readObject();
        this.age = in.readInt();
    }
}

我們接著撰寫測驗類：

public class serTest2 {
    public static void main(String[] args) throws Exception, IOException {
        SerializeUser();
        DeSerializeUser();
    }

    /**
     * 序列化方法
     * @throws IOException
     */
    private static void SerializeUser() throws  IOException {
        ExUser user = new ExUser();
        user.setAge(10);
        user.setName("小王");

        //序列化物件到指定的檔案中
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\jun\\Desktop\\example"));
        oos.writeObject(user);
        oos.close();
        System.out.println("序列化物件成功");
    }

    /**
     * 反序列化方法
     * @throws IOException
     * @throws ClassNotFoundException
     */
    private static void DeSerializeUser() throws  IOException, ClassNotFoundException {
        File file = new File("C:\\Users\\jun\\Desktop\\example");
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        ExUser newUser = (ExUser)ois.readObject();
        System.out.println("反序列化物件成功:"+ newUser.getName()+ ","+newUser.getAge());
    }
}

結果：

序列化物件成功
反序列化物件成功:小王,10

因為序列化和反序列化方法需要自己實作，因此可以指定序列化哪些屬性，transient關鍵字在這里是無效的，

對Externalizable物件反序列化時，會先呼叫類的無參構造方法，這是有別于默認反序列方式的，如果把類的不帶引數的構造方法洗掉，或者把該構造方法的訪問權限設定為private、默認或protected級別，會拋出java.io.InvalidException: no valid constructor例外，因此Externalizable物件必須有默認建構式，而且必需是public的，

serialVersionUID的作用

如果反序列化使用的serialVersionUID與序列化時使用的serialVersionUID不一致，會報InvalidCalssException例外，這樣就保證了專案迭代升級前后的兼容性
serialVersionUID是序列化前后的唯一識別符號，只要版本號serialVersionUID相同，即使更改了序列化屬性，物件也可以正確被反序列化回來，
默認如果沒有人為顯式定義過serialVersionUID，那編譯器會為它自動宣告一個！

serialVersionUID有兩種顯式的生成方式：

默認的1L，比如：private static final long serialVersionUID = 1L;
根據類名、介面名、成員方法及屬性等來生成一個64位的哈希欄位，比如：

private static final long serialVersionUID = xxxxL;

靜態變數不會被序列化

凡是被static修飾的欄位是不會被序列化的，我們來看一個例子：

//物體類
public class Student implements Serializable {
    private String name;
    public static Integer age;//靜態變數



    public String getName() {
        return name;
    }

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

    public static Integer getAge() {
        return age;
    }

    public static void setAge(Integer age) {
        Student.age = age;
    }
}

//測驗類
public class shallowCopyTest {

    public static void main(String[] args) throws Exception {
        Student student1 = new Student();
        student1.age = 11;

        //序列化，將資料寫入指定的檔案中
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\student1"));
        oos.writeObject(student1);
        oos.close();

        Student student2 = new Student();
        student2.age = 21;

        //序列化，將資料寫入指定的檔案中
        ObjectOutputStream oos2 = new ObjectOutputStream(new FileOutputStream("D:\\student2"));
        oos2.writeObject(student1);
        oos2.close();

        //讀取指定的檔案
        File file = new File("D:\\student1");
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        Student student1_new = (Student)ois.readObject();
        System.out.println("反序列化物件,student1.age="+ student1_new.getAge());

        //讀取指定的檔案
        File file2 = new File("D:\\student1");
        ObjectInputStream ois2 = new ObjectInputStream(new FileInputStream(file2));
        Student student2_new = (Student)ois2.readObject();
        System.out.println("反序列化物件,student2.age="+ student2_new.getAge());


    }



}

結果：

反序列化物件,student1.age=21
反序列化物件,student2.age=21

為啥結果都是21？
我們知道物件的序列化是操作的堆記憶體中的資料，而靜態的變數又稱作類變數，其資料存放在方法區里，類一加載，就初始化了，
又因為靜態變數age沒有被序列化，根本就沒寫入檔案流中，所以我們列印的值其實一直都是當前Student類的靜態變數age的值，而靜態變數又是所有的物件共享的一個變數，所以就都是21

使用序列化實作深拷貝

我們再來看一個例子：

//物體類 繼承Cloneable
public class Person implements Serializable{
    public String name;//姓名
    public int height;//身高
    public StringBuilder something;

...//省略 getter setter


    public Object deepClone() throws Exception{
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
    
        oos.writeObject(this);
    
        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
    
        return ois.readObject();
    }

}

//測驗類，這邊類名筆者就不換了，在之前的基礎上改改
public class shallowCopyTest {

    public static void main(String[] args) throws Exception {
        Person p1 = new Person("小張", 180, new StringBuilder("今天天氣很好"));
        Person p2 = (Person)p1.deepClone();

        System.out.println("物件是否相等："+ (p1 == p2));
        System.out.println("p1 屬性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
        System.out.println("p2 屬性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());


        // change
        p1.setName("小王");
        p1.setHeight(200);
        p1.getSomething().append(",適合出去玩");
        System.out.println("...after p1 change....");

        System.out.println("p1 屬性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
        System.out.println("p2 屬性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());

    }
}

結果：

物件是否相等：false
p1 屬性值=小張,180,今天天氣很好
p2 屬性值=小張,180,今天天氣很好
...after p1 change....
p1 屬性值=小王,200,今天天氣很好,適合出去玩
p2 屬性值=小張,180,今天天氣很好

詳情見：https://mp.weixin.qq.com/s/M4--Btn24NIggq8UBdWvAw

常見序列化協議對比

除了JDK 自帶的序列化方式，還有一些其他常見的序列化協議：

基于二進制： hessian、kyro、protostuff
文本類序列化方式： JSON 和 XML

采用哪種序列化方式，我們一般需要考慮序列化之后的資料大小，序列化的耗時，是否支持跨平臺、語言，或者公司團隊的技識訓累，這邊就不展開講了，大家感興趣自行去了解

小結

JDK自帶序列化方法一般有2種：繼承Serializable介面和繼承Externalizable介面
static修飾的類變數、transient修飾的實體變數都不會被序列化，
序列化物件的參考型別成員變數，也必須是可序列化的
serialVersionUID 版本號是序列化和反序列化前后唯一標識，建議顯式定義
序列化和反序列化的程序其實是有漏洞的，因為從序列化到反序列化是有中間程序的，如果被別人拿到了中間位元組流，然后加以偽造或者篡改，反序列化出來的物件會有一定風險，可以重寫readObject()方法，加以限制
除了JDK自帶序列化方法，還有hessian、kyro、protostuff、 JSON 和 XML等

參考資料：
《On Java 8》
https://tech.meituan.com/2015/02/26/serialization-vs-deserialization.html
https://www.zhihu.com/question/26475281/answer/1898221893

本篇文章到這里就結束啦，很感謝你能看到最后，如果覺得文章對你有幫助，別忘記關注我！更多精彩的文章

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/502798.html

標籤：Java

上一篇：Mybatis-Plus高級之LambdaQueryWrapper，Wrappers.＜物體類＞lambdaQuery的使用

下一篇：面試官：HashSet 的實作原理是怎樣的？底層是什么資料結構？被問到了。。