關於 Java 對象序列化您不知道的 5 件事

Java 序列化簡介

Java 對象序列化是 JDK 1.1 中引入的一組開創性特性之一，用於作爲一種將 Java 對象的狀態轉換爲字節數組，以便存儲或傳輸的機制，以後，仍可以將字節數組轉換回 Java 對象原有的狀態。

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

清單 1 顯示一個實現 Serializable 的 Person 類。

清單 1. Serializable Person

public class Person implements java.io.Serializable {
	public Person(String fn, String ln, int a) {
		this.firstName = fn;
		this.lastName = ln;
		this.age = a;
	}

	public String getFirstName() {
		return firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public int getAge() {
		return age;
	}

	public Person getSpouse() {
		return spouse;
	}

	public void setFirstName(String value) {
		firstName = value;
	}

	public void setLastName(String value) {
		lastName = value;
	}

	public void setAge(int value) {
		age = value;
	}

	public void setSpouse(Person value) {
		spouse = value;
	}

	public String toString() {
		return "[Person: firstName=" + firstName + " lastName=" + lastName
				+ " age=" + age + " spouse=" + spouse.getFirstName() + "]";
	}

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

}

將 Person 序列化後，很容易將對象狀態寫到磁盤，然後重新讀出它

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerTest {
	public void serializeToDisk() {
		try {
			Person ted = new Person("Ted", "Neward", 39);
			Person charl = new Person("Charlotte", "Neward", 38);

			ted.setSpouse(charl);
			charl.setSpouse(ted);

			FileOutputStream fos = new FileOutputStream("tempdata.ser");
			/**
			 * 實際上，序列化的思想是 “凍結” 對象狀態，傳輸對象狀態（寫到磁盤、通過網絡傳輸等等），然後 “解凍” 狀態，重新獲得可用的
			 * Java 對象。所有這些事情的發生有點像是魔術，這要歸功於
			 * ObjectInputStream/ObjectOutputStream
			 * 類、完全保真的元數據以及程序員願意用Serializable 標識接口標記他們的類，從而 “參與” 這個過程。
			 */
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			oos.writeObject(ted);
			oos.close();
		} catch (Exception ex) {
			System.out
					.println("Exception thrown during test: " + ex.toString());
		}

		try {
			FileInputStream fis = new FileInputStream("./tempdata.ser");
			ObjectInputStream ois = new ObjectInputStream(fis);
			Person ted = (Person) ois.readObject();
			ois.close();

			if (!ted.getFirstName().equals("Ted")) {
				System.out.println("error1");
			} else {
				System.out.println("KO1");
			}
			if (!ted.getSpouse().getFirstName().equals("Charlotte"))
				System.out.println("error2");
			else
				System.out.println("KO2");
			// Clean up the file
			new File("tempdata.ser").delete();
		} catch (Exception ex) {
			System.out
					.println("Exception thrown during test: " + ex.toString());
		}
	}

	public static void main(String[] args) {
		new SerTest().serializeToDisk();
	}
}

1. 序列化允許重構

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

Java Object Serialization 規範可以自動管理的關鍵任務是：

將新字段添加到類中
將字段從 static 改爲非 static
將字段從 transient 改爲非 transient

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

重構序列化類

既然已經知道序列化允許重構，我們來看看當把新字段添加到 Person 類中時，會發生什麼事情。

如清單 3 所示，PersonV2 在原先 Person 類的基礎上引入一個表示性別的新字段。

清單 3. 將新字段添加到序列化的 Person 中

enum Gender
{
    MALE, FEMALE
}
 
public class Person
    implements java.io.Serializable
{
    public Person(String fn, String ln, int a, Gender g)
    {
        this.firstName = fn; this.lastName = ln; this.age = a; this.gender = g;
    }
   
    public String getFirstName() { return firstName; }
    public String getLastName() { return lastName; }
    public Gender getGender() { return gender; }
    public int getAge() { return age; }
    public Person getSpouse() { return spouse; }
 
    public void setFirstName(String value) { firstName = value; }
    public void setLastName(String value) { lastName = value; }
    public void setGender(Gender value) { gender = value; }
    public void setAge(int value) { age = value; }
    public void setSpouse(Person value) { spouse = value; }
 
    public String toString()
    {
        return "[Person: firstName=" + firstName + 
            " lastName=" + lastName +
            " gender=" + gender +
            " age=" + age +
            " spouse=" + spouse.getFirstName() +
            "]";
    }    
 
    private String firstName;
    private String lastName;
    private int age;
    private Person spouse;
    private Gender gender;
}

序列化使用一個 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 字段。畢竟，女士忌談年齡。我們可以在序列化之前模糊化該數據，將數位循環左移一位，然後在反序列化之後復位。（您可以開發更安全的算法，當前這個算法只是作爲一個例子。）

爲了 “hook” 序列化過程，我們將在 Person 上實現一個 writeObject 方法；爲了 “hook” 反序列化過程，我們將在同一個類上實現一個readObject 方法。重要的是這兩個方法的細節要正確 — 如果訪問修改方法、參數或名稱不同於清單 4 中的內容，那麼代碼將不被察覺地失敗，Person 的 age 將暴露。

清單 4. 模糊化序列化數據

public class Person
    implements java.io.Serializable
{
    public Person(String fn, String ln, int a)
    {
        this.firstName = fn; this.lastName = ln; this.age = a;
    }
 
    public String getFirstName() { return firstName; }
    public String getLastName() { return lastName; }
    public int getAge() { return age; }
    public Person getSpouse() { return spouse; }
     
    public void setFirstName(String value) { firstName = value; }
    public void setLastName(String value) { lastName = value; }
    public void setAge(int value) { age = value; }
    public void setSpouse(Person value) { spouse = value; }
 
    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;
    }
     
    public String toString()
    {
        return "[Person: firstName=" + firstName + 
            " lastName=" + lastName +
            " age=" + age +
            " spouse=" + (spouse!=null ? spouse.getFirstName() : "[null]") +
            "]";
    }      
 
    private String firstName;
    private String lastName;
    private int age;
    private Person spouse;
}

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

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

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

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

結合使用這兩種對象，便可以輕鬆地對序列化數據進行密封和簽名，而不必強調關於數字簽名驗證或加密的細節。很簡潔，是吧？

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

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

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

打包和解包代理

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

清單 5. 你完整了我，我代替了你

class PersonProxy
    implements java.io.Serializable
{
    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();
        }
    }
 
    public String data;
    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;
    }
}
 
public class Person
    implements java.io.Serializable
{
    public Person(String fn, String ln, int a)
    {
        this.firstName = fn; this.lastName = ln; this.age = a;
    }
 
    public String getFirstName() { return firstName; }
    public String getLastName() { return lastName; }
    public int getAge() { return age; }
    public Person getSpouse() { return spouse; }
 
    private Object writeReplace()
        throws java.io.ObjectStreamException
    {
        return new PersonProxy(this);
    }
     
    public void setFirstName(String value) { firstName = value; }
    public void setLastName(String value) { lastName = value; }
    public void setAge(int value) { age = value; }
    public void setSpouse(Person value) { spouse = value; }   
 
    public String toString()
    {
        return "[Person: firstName=" + firstName + 
            " lastName=" + lastName +
            " age=" + age +
            " spouse=" + spouse.getFirstName() +
            "]";
    }    
     
    private String firstName;
    private String lastName;
    private int age;
    private Person spouse;
}

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

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

5. 信任，但要驗證

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

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

關於 Java 對象序列化您不知道的 5 件事

Java 序列化簡介

清單 1. Serializable Person

1. 序列化允許重構

重構序列化類

清單 3. 將新字段添加到序列化的 Person 中

2. 序列化並不安全

模糊化序列化數據

清單 4. 模糊化序列化數據

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

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

打包和解包代理

清單 5. 你完整了我，我代替了你

5. 信任，但要驗證

Java習慣用法（上）

C++函數參數讀取順序

Sparse Autoencoder(2) --- BP(反向傳播)

：億級Web系統搭建——單機到分佈式集羣

Java Transient 關鍵字

Mac下配置sublime實現LaTeX

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

linux以太網驅動總結