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

關於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();
    }
}

報錯了，我們發現之前的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序列化有了更多的瞭解？

作者：楊亨

來源：宜信技術學院

原文地址https://my.oschina.net/u/4007037/blog/3190924

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

關於接口協議，你必須要知道這些！

一鍵自動化博客發佈工具,用過的人都說好(頭條篇)

美團一面：項目中有 10000 個 if else 如何優化？想了半天，被問懵了！

京東面試：如何進行JVM調優？

01 穩定性（一）如何應對事故並做好覆盤？

線程池那些坑爹的參數-核心線程數&最大線程數&工作隊列

Stream流常用方法總結

Java多線程之深入解析ThreadLocal和ThreadLocalMap

.NET Core Session源碼探究

Python 爲什麼沒有 main 函數？爲什麼我不推薦寫 main 函數？

【asp.net core 系列】3 視圖以及視圖與控制器

Docker虛擬機配置手札（centos）

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

linux以太網驅動總結