Categories
程式開發

關於Java序列化的問題你真的會嗎?


在持久化數據對象的時候我們很少使用Java序列化,而是使用數據庫等方式來實現。但是在我看來,Java 序列化是一個很重要的內容,序列化不僅可以保存對像到磁盤進行持久化,還可以通過網絡傳輸。在平時的面試當中,序列化也是經常被談及的一塊內容。

談到序列化時,大家可能知道將類實現Serializable接口就可以達到序列化的目的,但當看到關於序列化的面試題時我們卻常常一臉懵逼。

1)可序列化接口和可外部接口的區別是什麼?

2)序列化時,你希望某些成員不要序列化?該如何實現?

3)什麼是 serialVersionUID ?如果不定義serialVersionUID,會發生什麼?

是不是突然發現我們對這些問題其實都還存在很多疑惑?本文將總結一些Java序列化的常見問題,並且通過demo來進行測試和解答

一、什麼是 Java 序列化?

序列化是把對象改成可以存到磁盤或通過網絡發送到其它運行中的 Java 虛擬機的二進制格式的過程,並可以通過反序列化恢復對象狀態。 Java 序列化API給開發人員提供了一個標準機制:通過實現 java.io.Serializable 或者 java.io.Externalizable 接口,ObjectInputStream 及ObjectOutputStream 處理對象序列化。實現java.io.Externalizable 接口的話,Java 程序員可自由選擇基於類結構的標準序列化或是它們自定義的二進制格式,通常認為後者才是最佳實踐,因為序列化的二進製文件格式成為類輸出API的一部分,可能破壞Java 中私有和包可見的屬性的封裝。

序列化到底有什麼用

實現 java.io.Serializable

定義用戶類:

class User implements Serializable {
    private String username;
    private String passwd;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPasswd() {
        return passwd;
    }

    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }
}

我們把對象序列化,通過ObjectOutputStream存儲到txt文件中,再通過ObjectInputStream讀取txt文件,反序列化成User對象。

public class TestSerialize {

    public static void main(String[] args) {

        User user = new User();
        user.setUsername("hengheng");
        user.setPasswd("123456");

        System.out.println("read before Serializable: ");
        System.out.println("username: " + user.getUsername());
        System.err.println("password: " + user.getPasswd());

        try {
            ObjectOutputStream os = new ObjectOutputStream(
                    new FileOutputStream("/Users/admin/Desktop/test/user.txt"));
            os.writeObject(user); // 将User对象写进文件
            os.flush();
            os.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            ObjectInputStream is = new ObjectInputStream(new FileInputStream(
                    "/Users/admin/Desktop/test/user.txt"));
            user = (User) is.readObject(); // 从流中读取User的数据
            is.close();

            System.out.println("nread after Serializable: ");
            System.out.println("username: " + user.getUsername());
            System.err.println("password: " + user.getPasswd());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

運行結果如下:

序列化前数据:
username: hengheng
password: 123456

序列化后数据:
username: hengheng
password: 123456

到這裡,我們大概知道了什麼是序列化。

二、序列化時如何保證某些成員不被序列化?

答案:聲明該成員為靜態或瞬態,在 Java 序列化過程中則不會被序列化

  • 靜態變量:加static關鍵字。
  • 瞬態變量:加transient關鍵字。

我們先嘗試把變量聲明為瞬態。

class User implements Serializable {
    private String username;
    private transient String passwd;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPasswd() {
        return passwd;
    }

    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }

在密碼字段前加上了transient關鍵字再運行。運行結果:

序列化前数据:
username: hengheng
password: 123456

序列化后数据:
username: hengheng
password: null

通過運行結果發現密碼沒有被序列化,達到了我們的目的。

再嘗試在用戶名前加static關鍵字。

class User implements Serializable {
    private static String username;
    private transient String passwd;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPasswd() {
        return passwd;
    }

    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }

運行結果:

序列化前数据:
username: hengheng
password: 123456

序列化后数据:
username: hengheng
password: null

我們發現運行後的結果和預期的不一樣,按理說username也應該變為null才對。是什麼原因呢?

原因是:反序列化後類中static型變量username的值為當前JVM中對應的靜態變量的值,而不是反序列化得出的

我們來證明一下:

public class TestSerialize {

    public static void main(String[] args) {

        User user = new User();
        user.setUsername("hengheng");
        user.setPasswd("123456");

        System.out.println("序列化前数据: ");
        System.out.println("username: " + user.getUsername());
        System.err.println("password: " + user.getPasswd());

        try {
            ObjectOutputStream os = new ObjectOutputStream(
                    new FileOutputStream("/Users/admin/Desktop/test/user.txt"));
            os.writeObject(user); // 将User对象写进文件
            os.flush();
            os.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        User.username = "小明";
        try {
            ObjectInputStream is = new ObjectInputStream(new FileInputStream(
                    "/Users/admin/Desktop/test/user.txt"));
            user = (User) is.readObject(); // 从流中读取User的数据
            is.close();

            System.out.println("n序列化后数据: ");
            System.out.println("username: " + user.getUsername());
            System.err.println("password: " + user.getPasswd());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class User implements Serializable {
    public static String username;
    private transient String passwd;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPasswd() {
        return passwd;
    }

    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }
}

在反序列化前把靜態變量username的值改為『小明』。

User.username = "小明";

再運行一次:

序列化前数据:
username: hengheng
password: 123456

序列化后数据:
username: 小明
password: null

果然,這裡的username是JVM中靜態變量的值,並不是反序列化得到的值。

三、serialVersionUID有什麼用?

我們經常會在類中自定義一個serialVersionUID:

private static final long serialVersionUID = 8294180014912103005L

這個serialVersionUID有什麼用呢?如果不設置的話會有什麼後果?

serialVersionUID 是一個 private static final long 型 ID,當它被印在對像上時,它通常是對象的哈希碼。 serialVersionUID可以自己定義,也可以自己去生成

不指定 serialVersionUID的後果是:當你添加或修改類中的任何字段時,已序列化類將無法恢復,因為新類和舊序列化對像生成的 serialVersionUID 將有所不同。 Java 序列化的過程是依賴於正確的序列化對象恢復狀態的,並在序列化對象序列版本不匹配的情況下引發 java.io.InvalidClassException 無效類異常。

舉個例子大家就明白了:

我們保持之前保存的序列化文件不變,然後修改User類。

class User implements Serializable {
    public static String username;
    private transient String passwd;
    private String age;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPasswd() {
        return passwd;
    }

    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }

    public String getAge() {
        return age;
    }

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

加了一個屬性age,然後單另寫一個反序列化的方法:

public static void main(String[] args) {
        try {
            ObjectInputStream is = new ObjectInputStream(new FileInputStream(
                    "/Users/admin/Desktop/test/user.txt"));
            User user = (User) is.readObject(); // 从流中读取User的数据
            is.close();

            System.out.println("n修改User类之后的数据: ");
            System.out.println("username: " + user.getUsername());
            System.err.println("password: " + user.getPasswd());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

關於Java序列化的問題你真的會嗎? 1

報錯了,我們發現之前的User類生成的serialVersionUID和修改後的serialVersionUID不一樣(因為是通過對象的哈希碼生成的),導致了InvalidClassException異常。

自定義serialVersionUID:

class User implements Serializable {
    private static final long serialVersionUID = 4348344328769804325L;

    public static String username;
    private transient String passwd;
    private String age;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPasswd() {
        return passwd;
    }

    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }

    public String getAge() {
        return age;
    }

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

再試一下:

序列化前数据:
username: hengheng
password: 123456

序列化后数据:
username: 小明
password: null

運行結果無報錯,所以一般都要自定義serialVersionUID。

四、是否可以自定義序列化過程?

答案當然是可以的

之前我們介紹了序列化的第二種方式:

實現Externalizable接口,然後重寫writeExternal() 和readExternal()方法,這樣就可以自定義序列化

比如我們嘗試把變量設為瞬態。

public class ExternalizableTest implements Externalizable {

    private transient String content = "我是被transient修饰的变量哦";

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(content);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        content = (String) in.readObject();
    }

    public static void main(String[] args) throws Exception {

        ExternalizableTest et = new ExternalizableTest();
        ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
                new File("test")));
        out.writeObject(et);

        ObjectInput in = new ObjectInputStream(new FileInputStream(new File(
                "test")));
        et = (ExternalizableTest) in.readObject();
        System.out.println(et.content);

        out.close();
        in.close();
    }
}

運行結果:

我是被transient修饰的变量哦

這裡實現的是Externalizable接口,則沒有任何東西可以自動序列化,需要在writeExternal方法中進行手工指定所要序列化的變量,這與是否被transient修飾無關。

通過上述介紹,是不是對Java序列化有了更多的了解?

本文轉載自公眾號宜信技術學院(ID:CE_TECH)。

原文鏈接

https://mp.weixin.qq.com/s/7IucJdHLfCe4CmwH5h7Axw