回首Java——Java序列化機制(Serialization,Deserialization)

Java 序列化簡介

Serialization（序列化）是JDK 1.1 中引入的一組開創性特性之一,是一種將對象以一連串的字節描述的過程，以便存儲或傳輸的機制；反序列化deserialization是一種將這些字節重建成一個對象的過程，以後，仍可以將字節數組轉換回 Java 對象原有的狀態。

實際上，序列化的思想是 “凍結” 對象狀態，傳輸對象狀態（寫到磁盤、通過網絡傳輸等等），然後 “解凍” 狀態，重新獲得可用的 Java 對象。所有這些事情的發生有點像是魔術，這要歸功於 ObjectInputStream/ObjectOutputStream 類、完全保真的元數據以及程序員願意用Serializable 標識接口標記他們的類，從而 “參與” 這個過程。

序列化的必要性(爲什麼要序列化)

當兩個進程在進行遠程通信時，彼此可以發送各種類型的數據。無論是何種類型的數據，都會以二進制序列的形式在網絡上傳送。發送方需要把這個對象轉換爲字節序列，才能在網絡上傳送；接收方則需要把字節序列再恢復爲對象。

比如：**在分佈式環境中經常需要將Object從這一端網絡或設備傳遞到另一端。
這就需要有一種可以在兩端傳輸數據的協議。**
說的再直接點，序列化的目的就是爲了跨進程傳遞格式化數據。

如何進行序列化

下面具體的舉一個例子

/**
 * 要序列化的類
 */
public class Person implements Serializable {

    /**
     * 此字段非常重要,它是通過對原始版本的 Person 類運行 JDK serialver命令計算出的。
     */
    private static final long serialVersionUID = 1L;

    public Person(String fn, String ln, int a) {
        this.firstName = fn;
        this.lastName = ln;
        this.age = a;
    }

    private String firstName;
    private String lastName;
    private int age;
    private Person spouse;


    // get/set方法...省略

}


/**
 * 對Person對象進行S/D
 *
 */
public class PersonSerializeToDisk {

    private static File file = new File("person.ser");

    @Test
    public void fosDis() {
        Person p1 = new Person("Ted","Neward",35);
        Person p2 = new Person("Charlotte","Neward",36);

        p1.setSpouse(p2);

        if(file.exists()) {
            file.delete();
        }

        /**
         * 將對象寫進文件
         */

        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        try {
            fos = new FileOutputStream(file);
            oos = new ObjectOutputStream(fos);
            oos.writeObject(p1);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void fisDis() {
        /**
         * 從文件中讀取反序列化對象
         */
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            fis = new FileInputStream(file);
            ois = new ObjectInputStream(fis);
            Person desPerson = (Person)ois.readObject();
            System.out.println("desPerson.getFirstName():" + desPerson.getFirstName());
            assertEquals(desPerson.getFirstName(),"Ted");
            System.out.println("desPerson.getSpouse().getFirstName():" + desPerson.getSpouse().getFirstName());
            assertEquals(desPerson.getSpouse().getFirstName(),"Charlotte");
            System.out.println("desPerson.getAge():" + desPerson.getAge());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

將 Person 序列化後，很容易將對象狀態寫到磁盤，然後重新讀出它，到現在爲止，還沒有看到什麼新鮮的或令人興奮的事情，但是這是一個很好的出發點。我們將使用上面的Person 對象來展示關於Java對象序列化的幾件事。

Java對象序列化的幾件事

1.序列化允許重構

序列化允許一定數量的類變種，甚至重構之後也是如此，ObjectInputStream 仍可以很好地將其讀出來。

java Object Serialization 規範可以自動管理的關鍵任務是：
* 將新字段添加到類中
* 將字段從 static 改爲非 static
* 將字段從 transient 改爲非 transient

取決於所需的向後兼容程度，轉換字段形式（從非 static 轉換爲 static 或從非 transient 轉換爲 transient）或者刪除字段需要額外的消息傳遞。

----------------------

**重構序列化類**

既然已經知道序列化允許重構，來看看把新字段添加到 Person 類中.下面把性別新增加上了，然後反序列化一下

enum Gender{
    MALE,FEMALE
}
public class Person implements Serializable {

    /**
     * 此字段非常重要,它是通過對原始版本的 Person 類運行 JDK serialver命令計算出的。
     */
    private static final long serialVersionUID = 1L;

    public Person(String fn, String ln, int a,Gender g) {
        this.firstName = fn;
        this.lastName = ln;
        this.age = a;
        this.gender = g;
    }

    private String firstName;
    private String lastName;
    private int age;
    private Person spouse;
    private Gender gender;


    //get/set方法 .....


    @Test
    public void fisDis() {
        /**
         * 從文件中讀取反序列化對象
         */
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            fis = new FileInputStream(file);
            ois = new ObjectInputStream(fis);
            Person desPerson = (Person)ois.readObject();
            System.out.println("desPerson.getFirstName():" + desPerson.getFirstName());
            assertEquals(desPerson.getFirstName(),"Ted");
            System.out.println("desPerson.getSpouse().getFirstName():" + desPerson.getSpouse().getFirstName());
                        assertEquals(desPerson.getSpouse().getFirstName(),"Charlotte");
                        System.out.println("desPerson.getGender():" + desPerson.getGender());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

這裏的性別輸出結果爲null

序列化使用一個 hash，該 hash 是根據給定源文件中幾乎所有東西 — 方法名稱、字段名稱、字段類型、訪問修改方法等 — 計算出來的，序列化將該 hash 值與序列化流中的 hash 值相比較。

爲了使 Java 運行時相信兩種類型實際上是一樣的，第二版和隨後版本的 Person 必須與第一版有相同的序列化版本 hash（存儲爲 private static final serialVersionUID 字段）。因此，我們需要 serialVersionUID 字段，它是通過對原始（或 V1）版本的 Person 類運行 JDK serialver命令計算出的。

一旦有了 Person 的 serialVersionUID，不僅可以從原始對象 Person 的序列化數據創建 PersonV2 對象（當出現新字段時，新字段被設爲缺省值，最常見的是“null”），還可以反過來做：即從 PersonV2 的數據通過反序列化得到 Person，這毫不奇怪。

2.序列化並不安全

讓 Java 開發人員詫異並感到不快的是，序列化二進制格式完全編寫在文檔中，並且完全可逆。實際上，只需將二進制序列化流的內容轉儲到控制檯，就足以看清類是什麼樣子，以及它包含什麼內容。

這對於安全性有着不良影響。例如，當通過 RMI 進行遠程方法調用時，通過連接發送的對象中的任何 private 字段幾乎都是以明文的方式出現在套接字流中，這顯然容易招致哪怕最簡單的安全問題。

幸運的是，序列化允許 “hook” 序列化過程，並在序列化之前和反序列化之後保護（或模糊化）字段數據。可以通過在 Serializable 對象上提供一個 writeObject 方法來做到這一點。

模糊化序列化數據

假設 Person 類中的敏感數據是 age 字段。畢竟，女士忌談年齡。我們可以在序列化之前模糊化該數據，將數位循環左移一位，然後在反序列化之後復位。(您可以開發更安全的算法，當前這個算法只是作爲一個例子,這是最簡單的一個算法，移位操作)

**WriteObject 和ReadObject方法對於實現了Serializable 接口
的類來說是可選方法。如果實現了，那麼在序列化/反序列化的時候，會調用。否則，默認的序列化/反序列化將被執行。在這兩個方法裏，只需要關心方法所在類本身的字段域，不需要對其父類或子類負責。在這兩個方法裏，我們還是需要調用ObjectOutputStream的方法，defaultWriteObject/defaultReadObject 以執行Java的默認序列化/反序列化過程。**

爲了 “hook” 序列化過程，我們將在 Person 上實現一個 writeObject 方法；爲了 “hook” 反序列化過程，我們將在同一個類上實現一個readObject 方法。重要的是這兩個方法的細節要正確.

public class Person implements Serializable {

    /**
     * 此字段非常重要,它是通過對原始（或 V1）版本的 Person 類運行 JDK serialver命令計算出的。
     */
    private static final long serialVersionUID = 1L;

    public Person(String fn, String ln, int a) {
        this.firstName = fn;
        this.lastName = ln;
        this.age = a;
    }

    /**
     * 加密
     */
    private void writeObject(java.io.ObjectOutputStream stream) throws java.io.IOException {
        // "Encrypt"/obscure the sensitive data
        age = age << 2;
        stream.defaultWriteObject();
    }

    /**
     * 解密,當不知道加密方法的時候，則不能解密
     */
    private void readObject(java.io.ObjectInputStream stream) throws java.io.IOException, ClassNotFoundException {
        stream.defaultReadObject();
        // "Decrypt"/de-obscure the sensitive data
        age = age >> 2;
    }

    private String firstName;
    private String lastName;
    private int age;
    private Person spouse;

    // get/set方法
}

這樣，只要不知道加密方法，就不能解密了。如果需要查看被模糊化的數據，總是可以查看序列化數據流/文件。而且，由於該格式被完全文檔化，即使不能訪問類本身，也仍可以讀取序列化流中的內容。

利用Transient關鍵字模糊關鍵數據

這個關鍵字的用途，大家應該都不陌生。它用來指定可序列化對象中，哪個變量不被序列化。如果你的對象中存放了一些敏感信息，不想讓別人看到的話。那麼就把存放這個敏感信息的變量聲明爲Transient. 如下代碼例子所示，Employee類中有一個私有變量_salary,我們在序列化時，想忽略這個敏感信息，那將它定義爲transient即可。

public class Person implements Serializable {

    /**
     * 此字段非常重要,它是通過對原始（或 V1）版本的 Person 類運行 JDK serialver命令計算出的。
     */
    private static final long serialVersionUID = 1L;

    private String firstName;
    private String lastName;
    private int age;
    private Person spouse;
    private transient double salary;

    public Person(String fn, String ln, int a) {
        this.firstName = fn;
        this.lastName = ln;
        this.age = a;
    }

    public Person(String fn, String ln, int a,double s) {
        this.firstName = fn;
        this.lastName = ln;
        this.age = a;
        this.salary = s;
    }

    // get/set方法


}

Console Result:

desPerson.getFirstName():Ted

desPerson.getSpouse().getFirstName():Charlotte

desPerson.getAge():35

desPerson.getSalary():0.0

只有salary的結果沒有被序列化

3.序列化的數據可以被簽名和密封

上一個技巧假設您想模糊化序列化數據，而不是對其加密或者確保它不被修改。當然，通過使用 writeObject 和 readObject 可以實現密碼加密和簽名管理，但其實還有更好的方式。

如果需要對整個對象進行加密和簽名，最簡單的是將它放在一個 javax.crypto.SealedObject 和/或 java.security.SignedObject 包裝器中。兩者都是可序列化的，所以將對象包裝在 SealedObject 中可以圍繞原對象創建一種 “包裝盒”。必須有對稱密鑰才能解密，而且密鑰必須單獨管理。同樣，也可以將 SignedObject 用於數據驗證，並且對稱密鑰也必須單獨管理。

你可能注意到這兩個類分別存放在了不同的Java package裏，雖然他們都對對象的真實性，完整性提供了保證，有人更傾向於在進行Java API設計時將他們放到一起。

結合使用這兩種對象，便可以輕鬆地對序列化數據進行密封和簽名，而不必強調關於數字簽名驗證或加密的細節.這裏使用SealedObject進行一下實例說明，從而我們能看到使用他們可以很方便的對可序列化的對象進行加密，從而保證信息安全。

private static File file = new File("person.ser");
    private static Key _key = null;

    @Test
    public void fosDis() {
        Person p1 = new Person("Ted","Neward",35,500.55);
        Person p2 = new Person("Charlotte","Neward",36);

        p1.setSpouse(p2);

        if(file.exists()) {
            file.delete();
        }

        /**
         * 將對象寫進文件
         */

        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        try {
            fos = new FileOutputStream(file);
            oos = new ObjectOutputStream(fos);

            /**
             * 加密
             */
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
            _key = keyGenerator.generateKey();
                        Cipher cipher = Cipher.getInstance("DESede");
                        cipher.init(Cipher.ENCRYPT_MODE, _key);
                        SealedObject so = new SealedObject(p1,cipher);

            oos.writeObject(so);

            System.out.println("Serialized - "+ p1.toString());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void fisDis() {
        /**
         * 從文件中讀取反序列化對象
         */
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            fis = new FileInputStream(file);
            ois = new ObjectInputStream(fis);

            SealedObject so = (SealedObject)ois.readObject();
            Person person = (Person)so.getObject(_key);//獲得解密的key
            System.out.println("Deserialized - "+ person.toString());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        PersonSerializeToDisk pst = new PersonSerializeToDisk();
        pst.fosDis();
        pst.fisDis();
    }

4.序列化允許將代理放在流中

很多情況下，類中包含一個核心數據元素，通過它可以派生或找到類中的其他字段。在此情況下，沒有必要序列化整個對象。可以將字段標記爲 transient，但是每當有方法訪問一個字段時，類仍然必須顯式地產生代碼來檢查它是否被初始化。

如果首要問題是序列化，那麼最好指定一個 flyweight 或代理放在流中。爲原始 Person 提供一個 writeReplace 方法，可以序列化不同類型的對象來代替它。類似地，如果反序列化期間發現一個 readResolve 方法，那麼將調用該方法，將替代對象提供給調用者。

打包和解包代理

writeReplace 和 readResolve 方法使 Person 類可以將它的所有數據（或其中的核心數據）打包到一個 PersonProxy 中，將它放入到一個流中，然後在反序列化時再進行解包。

有的地方是這樣說的: “通過實現writeReplace方法來自動返回一個替代的SealedObject對象不可行，會導致棧溢出。因爲SealedObject會對傳入的待加密對象進行深Copy。這個操作就是通過序列化完成的。所以，會遞歸成死循環。 “，這信息我目前沒太懂，這一塊若後續會涉及到。會補充上。

public class Person implements Serializable {

    /**
     * 此字段非常重要,它是通過對原始（或 V1）版本的 Person 類運行 JDK serialver命令計算出的。
     */
    private static final long serialVersionUID = 1L;

    public Person(String fn, String ln, int a) {
        this.firstName = fn;
        this.lastName = ln;
        this.age = a;
    }

    private Object writeReplace() throws java.io.ObjectStreamException {
        return new PersonProxy(this);
    }
}


public class PersonProxy implements Serializable {

    private static final long serialVersionUID = 1L;

    public String data;

    public PersonProxy(Person orig) {
        data = orig.getFirstName() + "," + orig.getLastName() + "," + orig.getAge();
        if (orig.getSpouse() != null) {
            Person spouse = orig.getSpouse();
            data = data + "," + spouse.getFirstName() + "," + spouse.getLastName() + "," + spouse.getAge();
        }
    }

    private Object readResolve() throws java.io.ObjectStreamException {
        String[] pieces = data.split(",");
        Person result = new Person(pieces[0], pieces[1], Integer.parseInt(pieces[2]));
        if (pieces.length > 3) {
            result.setSpouse(new Person(pieces[3], pieces[4], Integer.parseInt(pieces[5])));
            result.getSpouse().setSpouse(result);
        }
        return result;
    }

}

注意，PersonProxy 必須跟蹤 Person 的所有數據。這通常意味着代理需要是 Person 的一個內部類，以便能訪問 private 字段。有時候，代理還需要追蹤其他對象引用並手動序列化它們，例如 Person 的 spouse。

這種技巧是少數幾種不需要讀/寫平衡的技巧之一。例如，一個類被重構成另一種類型後的版本可以提供一個 readResolve 方法，以便靜默地將被序列化的對象轉換成新類型。類似地，它可以採用 writeReplace 方法將舊類序列化成新版本。

5.信任，但要驗證

認爲序列化流中的數據總是與最初寫到流中的數據一致，這沒有問題。但是，正如一位美國前總統所說的，“信任，但要驗證”。

對於序列化的對象，這意味着驗證字段，以確保在反序列化之後它們仍具有正確的值，“以防萬一”。爲此，可以實現 ObjectInputValidation接口，並覆蓋 validateObject() 方法。如果調用該方法時發現某處有錯誤，則拋出一個 InvalidObjectException。

Java 在反序列化的過程中不會對Deserialized的對象進行有效性檢查。而且，一旦對象是可序列化的，那就說明對象狀態對應的的字節序列可以脫離Java的安全體系存在。關鍵是這個序列化後的字節序列對用戶是可讀的，基本是明文顯示。所以在反序列化時，爲了安全起見，我們最好對得到的數據進行校驗。這時，需要我們實現接口java.io.ObjectInputValidation，這樣我們可以定義反序列化中的回調函數來進行驗證工作。下面舉個例子

public class Person implements Serializable, ObjectInputValidation {

    /**
     * 此字段非常重要,它是通過對原始（或 V1）版本的 Person 類運行 JDK serialver命令計算出的。
     */
    private static final long serialVersionUID = 1L;

    private String firstName;
    private String lastName;
    private int age;
    private Person spouse;
    private double salary;

    public Person(String fn, String ln, int a) {
        this.firstName = fn;
        this.lastName = ln;
        this.age = a;
    }

    public Person(String fn, String ln, int a, double s) {
        this.firstName = fn;
        this.lastName = ln;
        this.age = a;
        this.salary = s;
    }

    private void readObject(java.io.ObjectInputStream stream) throws java.io.IOException, ClassNotFoundException {
        stream.defaultReadObject();
        stream.registerValidation(this, 0);
        System.out.println("Customized readObject method called.");
    }

    @Override
    public void validateObject() throws InvalidObjectException {
        System.out.println("Validation object after deserialization.");
        if (salary < 0) {
            throw new InvalidObjectException("The Deserialized object is invalid. Salary can't be negative.");
        } else {
            System.out.println("The Deserialized object is valid.");
        }
    }

        //get/set方法 ......  
}

這樣，如果正確執行，就會進行相應的檢查，並是否拋出異常。

6.指定不要序列化

考慮這樣一個例子，父類實現了序列化接口，但是子類不想實現，這樣的情況，只需要自己手動在子類中writeObject和readObject方法中拋出異常NotSerializableException即可。

private void writeObject(java.io.ObjectOutputStream stream)  throws java.io.IOException  {  
        throw new NotSerializableException("This class is not serializable");  
}  

private void readObject(java.io.ObjectInputStream stream)  throws java.io.IOException, ClassNotFoundException  {  
    throw new NotSerializableException("This class is not serializable");  
}

最後

Java API在 JDK 1.1 的版本中還引入了 Externalizable 接口，通過實現該接口，用戶可以通過WriteExternal和ReadExternal方法對序列化/反序列化的過程進行完全掌控，當然我們也可以對字段進行滿足安全考慮的任何處理。實現該接口，靈活性增加了，但意味着用戶要自己對序列化/反序列化的過程負責，增加了用戶的複雜度，同時序列化/反序列化的性能問題是否會更突出，也是一個需要考慮的問題。

我以前做web開發的時候，只知道經理說讓所有的entity實現這個接口，一直也沒明白爲什麼，如今回首這些知識的時候，才懂得它的重要性，同時在寫這篇博客的時候也解決了我其它方面的很多疑問，比如說hadoop內部的自定義數據類型時候需要重寫readObject()和writeObject()方法，安全問題等。當你看到這些文字的時候，若日後需要帶新人講解這些知識的時候，一定要講全面，避免遇到我那種模糊學習模糊工作的情況。

參考：
* http://www.importnew.com/16151.html
* http://www.cnblogs.com/redcreen/articles/1955307.html
* http://blog.csdn.net/technerd/article/details/13094987

回首Java——Java序列化機制(Serialization,Deserialization)

Java 序列化簡介

序列化的必要性(爲什麼要序列化)

如何進行序列化

Java對象序列化的幾件事

模糊化序列化數據

利用Transient關鍵字模糊關鍵數據

打包和解包代理

最後

物理機開關機

HADOOP：HDFS的核心知識

HADOOP：MapReduce 的類型及常見知識

回首Java——深入理解HashMap相關

回首Java——Java序列化機制(Serialization,Deserialization)

LINUX： ftp,sftp,scp網絡傳輸命令配置及使用

Mac下配置sublime實現LaTeX

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

linux以太網驅動總結