Java回顧之序列化

　　第一篇：Java回顧之I/O

　　第二篇：Java回顧之網絡通信

　　第三篇：Java回顧之多線程

　　第四篇：Java回顧之多線程同步

　　第五篇：Java回顧之集合

 

　　在這篇文章里，我們關注對象序列化。

　　首先，我們來討論一下什么是序列化以及序列化的原理；然后給出一個簡單的示例來演示序列化和反序列化；有時有些信息是不應該被序列化的，我們應該如何控制；我們如何去自定義序列化內容；最后我們討論一下在繼承結構的場景中，序列化需要注意哪些內容。

　　序列化概述

　　序列化，簡單來講，就是以“流”的方式來保存對象，至於保存的目標地址，可以是文件，可以是數據庫，也可以是網絡，即通過網絡將對象從一個節點傳遞到另一個節點。

　　我們知道在Java的I/O結構中，有ObjectOutputStream和ObjectInputStream，它們可以實現將對象輸出為二進制流，並從二進制流中獲取對象，那為什么還需要序列化呢？這需要從Java變量的存儲結構談起，我們知道對Java來說，基礎類型存儲在棧上，復雜類型（引用類型）存儲在堆中，對於基礎類型來說，上述的操作時可行的，但對復雜類型來說，上述操作過程中，可能會產生重復的對象，造成錯誤。

　　而序列化的工作流程如下：

　　1）通過輸出流保存的對象都有一個唯一的序列號。

　　2）當一個對象需要保存時，先對其序列號進行檢查。

　　3）當保存的對象中已包含該序列號時，不需要再次保存，否則，進入正常保存的流程。

　　正是通過序列號的機制，序列化才可以完整准確的保存對象的各個狀態。

　　序列化保存的是對象中的各個屬性的值，而不是方法或者方法簽名之類的信息。對於方法或者方法簽名，只要JVM能夠找到正確的ClassLoader，那么就可以invoke方法。

　　序列化不會保存類的靜態變量，因為靜態變量是作用於類型，而序列化作用於對象。

　　簡單的序列化示例

　　序列化的完整過程包括兩部分：

　　1）使用ObjectOutputStream將對象保存為二進制流，這一步叫做“序列化”。

　　2）使用ObjectInputStream將二進制流轉換成對象，這一步叫做“反序列化”。

　　下面我們來演示一個簡單的示例，首先定義一個Person對象，它包含name和age兩個信息。

class Person implements Serializable
{
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    
    public String toString()
    {
        return "Name:" + name + "; Age:" + age;
    }
}

　　然后是兩個公共方法，用來完成讀、寫對象的操作：

private static void writeObject(Object obj, String filePath)
{
    try
    {
        FileOutputStream fos = new FileOutputStream(filePath);
        ObjectOutputStream os = new ObjectOutputStream(fos);
        os.writeObject(obj);
        os.flush();
        fos.flush();
        os.close();
        fos.close();
        System.out.println("序列化成功。");
    }
    catch(Exception ex)
    {
        ex.printStackTrace();
    }
}

private static Object readObject(String filePath)
{
    try
    {
        FileInputStream fis = new FileInputStream(filePath);
        ObjectInputStream is = new ObjectInputStream(fis);
        
        Object temp = is.readObject();
        
        fis.close();
        is.close();
        
        if (temp != null)
        {
            System.out.println("反序列化成功。");
            return temp;
        }
    }
    catch(Exception ex)
    {
        ex.printStackTrace();
    }
    
    return null;
}

　　這里，我們將對象保存的二進制流輸出到磁盤文件中。

　　接下來，我們首先來看“序列化”的方法：

private static void serializeTest1()
{
    Person person = new Person();
    person.setName("Zhang San");
    person.setAge(30);
    System.out.println(person);
    writeObject(person, "d:\\temp\\test\\person.obj");
}

　　我們定義了一個Person實例，然后將其保存到d:\temp\test\person.obj中。

　　最后，是“反序列化”的方法：

private static void deserializeTest1()
{    
    Person temp = (Person)readObject("d:\\temp\\test\\person.obj");
    
    if (temp != null)
    {
        System.out.println(temp);
    }
}

　　它從d:\temp\test\person.obj中讀取對象，然后進行輸出。

　　上述兩個方法的執行結果如下：

Name:Zhang San; Age:30
序列化成功。
反序列化成功。
Name:Zhang San; Age:30

　　可以看出，讀取的對象和保存的對象是完全一致的。

　　隱藏非序列化信息

　　有時，我們的業務對象中會包含很多屬性，而有些屬性是比較隱私的，例如年齡、銀行卡號等，這些信息是不太適合進行序列化的，特別是在需要通過網絡來傳輸對象信息時，這些敏感信息很容易被竊取。

　　Java使用transient關鍵字來處理這種情況，針對那些敏感的屬性，我們只需使用該關鍵字進行修飾，那么在序列化時，對應的屬性值就不會被保存。

　　我們還是看一個實例，這次我們定義一個新的Person2，其中age信息是我們不希望序列化的：

class Person2 implements Serializable
{
    private String name;
    private transient int age;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    
    public String toString()
    {
        return "Name:" + name + "; Age:" + age;
    }
}

　　注意age的聲明語句：

private transient int age;

　　下面是“序列化”和“反序列化”的方法：

private static void serializeTest2()
{
    Person2 person = new Person2();
    person.setName("Zhang San");
    person.setAge(30);
    System.out.println(person);
    writeObject(person, "d:\\temp\\test\\person2.obj");
}

private static void deserializeTest2()
{    
    Person2 temp = (Person2)readObject("d:\\temp\\test\\person2.obj");
    
    if (temp != null)
    {
        System.out.println(temp);
    }
}

　　它的輸出結果如下：

Name:Zhang San; Age:30
序列化成功。
反序列化成功。
Name:Zhang San; Age:0

　　可以看到經過反序列化的對象，age的信息變成了Integer的默認值0。

　　自定義序列化過程

　　我們可以對序列化的過程進行定制，進行更細粒度的控制。

　　思路是在業務模型中添加readObject和writeObject方法。下面看一個實例，我們新建一個類型，叫Person3：

class Person3 implements Serializable
{
    private String name;
    private transient int age;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    
    public String toString()
    {
        return "Name:" + name + "; Age:" + age;
    }
    
    private void writeObject(ObjectOutputStream os)
    {
        try
        {
            os.defaultWriteObject();
            os.writeObject(this.age);
            System.out.println(this);
            System.out.println("序列化成功。");
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
    }
    
    private void readObject(ObjectInputStream is)
    {
        try
        {
            is.defaultReadObject();
            this.setAge(((Integer)is.readObject()).intValue() - 1);
            System.out.println("反序列化成功。");
            System.out.println(this);
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
    }
}

　　請注意觀察readObject和writeObject方法，它們都是private的，接受的參數是ObjectStream，然后在方法體內調用了defaultReadObject或者defaultWriteObject方法。

　　這里age同樣是transient的，但是在保存對象的過程中，我們單獨對其進行了保存，在讀取時，我們將age信息讀取出來，並進行了減1處理。

　　下面是測試方法：

private static void serializeTest3()
{
    Person3 person = new Person3();
    person.setName("Zhang San");
    person.setAge(30);
    System.out.println(person);
    try
    {
        FileOutputStream fos = new FileOutputStream("d:\\temp\\test\\person3.obj");
        ObjectOutputStream os = new ObjectOutputStream(fos);
        os.writeObject(person);
        fos.close();
        os.close();
    }
    catch(Exception ex)
    {
        ex.printStackTrace();
    }
}

private static void deserializeTest3()
{    
    try
    {
        FileInputStream fis = new FileInputStream("d:\\temp\\test\\person3.obj");
        ObjectInputStream is = new ObjectInputStream(fis);
        is.readObject();
        fis.close();
        is.close();
    }
    catch(Exception ex)
    {
        ex.printStackTrace();
    }
}

　　輸出結果如下：

Name:Zhang San; Age:30
序列化成功。
反序列化成功。
Name:Zhang San; Age:29

　　可以看到，經過反序列化得到的對象，其age屬性已經減1。

　　探討serialVersionUID

　　在上文中，我們描述序列化原理時，曾經提及每個對象都會有一個唯一的序列號，這個序列號，就是serialVersionUID。

　　當我們的對象實現Serializable接口時，該接口可以為我們生成serialVersionUID。

　　有兩種方式來生成serialVersionUID，一種是固定值：1L，一種是經過JVM計算，不同的JVM采取的計算算法可能不同。

　　下面就是兩個serialVersionUID的示例：

private static final long serialVersionUID = 1L;
private static final long serialVersionUID = -2380764581294638541L;

　　第一行是采用固定值生成的；第二行是JVM經過計算得出的。

　　那么serialVersionUID還有其他用途嗎？

　　我們可以使用它來控制版本兼容。如果采用JVM生成的方式，我們可以看到，當我們業務對象的代碼保持不變時，多次生成的serialVersionUID也是不變的，當我們對屬性進行修改時，重新生成的serialVersionUID會發生變化，當我們對方法進行修改時，serialVersionUID不變。這也從另一個側面說明，序列化是作用於對象屬性上的。

　　當我們先定義了業務對象，然后對其示例進行了“序列化”，這時根據業務需求，我們修改了業務對象，那么之前“序列化”后的內容還能經過“反序列化”返回到系統中嗎？這取決於業務對象是否定義了serialVersionUID，如果定義了，那么是可以返回的，如果沒有定義，會拋出異常。

　　來看下面的示例，定義新的類型Person4：

class Person4 implements Serializable
{
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    private void xxx(){}
    
    public String toString()
    {
        return "Name:" + name + "; Age:" + age;
    }
}

　　然后運行下面的方法：

private static void serializeTest4()
{
    Person4 person = new Person4();
    person.setName("Zhang San");
    person.setAge(30);
    
    writeObject(person, "d:\\temp\\test\\person4.obj");
}

　　接下來修改Person4，追加address屬性：

class Person4 implements Serializable
{
    private String name;
    private int age;
    private String address;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    private void xxx(){}
    
    public String toString()
    {
        return "Name:" + name + "; Age:" + age;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getAddress() {
        return address;
    }
}

　　然后運行“反序列化”方法：

private static void deserializeTest4()
{    
    Person4 temp = (Person4)readObject("d:\\temp\\test\\person4.obj");
    
    if (temp != null)
    {
        System.out.println(temp);
    }
}

　　可以看到，運行結果如下：

java.io.InvalidClassException: sample.serialization.Person4; local class incompatible: stream classdesc serialVersionUID = -2380764581294638541, local class serialVersionUID = -473458100724786987
    at java.io.ObjectStreamClass.initNonProxy(Unknown Source)
    at java.io.ObjectInputStream.readNonProxyDesc(Unknown Source)
    at java.io.ObjectInputStream.readClassDesc(Unknown Source)
    at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
    at java.io.ObjectInputStream.readObject0(Unknown Source)
    at java.io.ObjectInputStream.readObject(Unknown Source)
    at sample.serialization.Sample.readObject(Sample.java:158)
    at sample.serialization.Sample.deserializeTest4(Sample.java:105)
    at sample.serialization.Sample.main(Sample.java:16)

　　但是當我們在Person4中添加serialVersionUID后，再次執行上述各步驟，得出的運行結果如下：

反序列化成功。
Name:Zhang San; Age:30

　　有繼承結構的序列化

　　業務對象會產生繼承，這在管理系統中是經常看到的，如果我們有下面的業務對象：

class Person5
{
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    
    public String toString()
    {
        return "Name:" + name + "; Age:" + age;
    }
    
    public Person5(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
}

class Employee extends Person5 implements Serializable
{
    public Employee(String name, int age) {
        super(name, age);
    }

    private String companyName;

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    public String getCompanyName() {
        return companyName;
    }
    
    public String toString()
    {
        return "Name:" + super.getName() + "; Age:" + super.getAge() + "; Company:" + this.companyName;
    }
}

　　Employee繼承在Person5，Employee實現了Serializable接口，Person5沒有實現，那么運行下面的方法：

private static void serializeTest5()
{
    Employee emp = new Employee("Zhang San", 30);
    emp.setCompanyName("XXX");
    
    writeObject(emp, "d:\\temp\\test\\employee.obj");
}

private static void deserializeTest5()
{    
    Employee temp = (Employee)readObject("d:\\temp\\test\\employee.obj");
    
    if (temp != null)
    {
        System.out.println(temp);
    }
}

　　會正常運行嗎？事實上不會，它會拋出如下異常：

java.io.InvalidClassException: sample.serialization.Employee; no valid constructor
    at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(Unknown Source)
    at java.io.ObjectStreamClass.checkDeserialize(Unknown Source)
    at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
    at java.io.ObjectInputStream.readObject0(Unknown Source)
    at java.io.ObjectInputStream.readObject(Unknown Source)
    at sample.serialization.Sample.readObject(Sample.java:158)
    at sample.serialization.Sample.deserializeTest5(Sample.java:123)
    at sample.serialization.Sample.main(Sample.java:18)

　　原因：在有繼承層次的業務對象，進行序列化時，如果父類沒有實現Serializable接口，那么父類必須提供默認構造函數。

　　我們為Person5添加如下默認構造函數：

public Person5()
{
    this.name = "Test";
    this.age = 1;
}

　　再次運行上述代碼，結果如下：

Name:Zhang San; Age:30; Company:XXX
序列化成功。
反序列化成功。
Name:Test; Age:1; Company:XXX

　　可以看到，反序列化后的結果，父類中的屬性，已經被父類構造函數中的賦值代替了！

　　因此，我們推薦在有繼承層次的業務對象進行序列化時，父類也應該實現Serializable接口。我們對Person5進行修改，使其實現Serializable接口，執行結果如下：

Name:Zhang San; Age:30; Company:XXX
序列化成功。
反序列化成功。
Name:Zhang San; Age:30; Company:XXX

　　這正是我們期望的結果。