Serializable java序列化

Bean Serializable Interface 的介面讓BEAN可以序列化，將其變成一個可儲存為以後使用的二進位制流。當一個BEAN被系列化到磁碟上或者其他任何地方，其狀態被儲存起來，其中的屬性值也不會改變。在BEAN的規範中，JSP並沒有要求BEAN實現Serializable介面。但是，如果您希望自己控制您所建立的元件的serialization程式，或者您想serialize並不是標準元件擴充套件的元件，您必須瞭解serialization and deserialization的細節。

　　有幾個原因你會把BEAN冷藏起來以備後用。有些伺服器通過將所有的SESSION 資料（包括BEAN）寫入磁碟來支援任意長的SESSION生命期，即使伺服器停機也不會丟失。當伺服器重新啟動後，序列化的資料被恢復。同樣的理由，在重負載的站點上支援伺服器分簇的環境中，許多伺服器通過序列化來複制SESSION。如果你的BEAN不支援序列化，伺服器就不能正確地儲存和傳輸類。

　　通過同樣的策略，你可以選擇將BEAN儲存在磁碟上或者資料庫中，以備後用。例如，也許可以將客戶的購物車實現為一個BEAN，在訪問期間將其儲存在資料庫中。

　　如果BEAN需要特殊的複雜的初始設定，可以將BEAN設定好後序列化儲存在磁碟上。這個BEAN的“快照”可以用在任何需要的地方，包括在$#@60;jsp:useBean$#@62;中用beanName屬性的呼叫。

　　$#@60;jsp:useBean$#@62;標籤中的beanName屬性，用來例項化一個序列化的BEAN，而不是用來從一個類建立一個全新的例項。如果BEAN還沒有建立，beanName屬性傳給java.beans.Bean.instantiate()方法，由類裝載器對類進行例項化。它首先假定存在一個序列化的BEAN（帶有副檔名.ser），然後會將其啟用。如果這個操作失敗，它就會例項化一個新的例項。




　　下面簡單介紹一下這個介面：

　　物件能包含其它的物件，而這其它的物件又可以包含另外的物件。JAVA serialization能夠自動的處理巢狀的物件。對於一個物件的簡單的域，writeObject()直接將值寫入流。而，當遇到一個物件域時，writeObject()被再次呼叫，如果這個物件內嵌另一個物件，那麼，writeObject() 又被呼叫，直到物件能被直接寫入流為止。程式設計師所需要做的是將物件傳入ObjectOutputStream 的writeObject() 方法，剩下的將又系統自動完成。下面的例子建立了一個呼叫mine物件的PersonalData物件。程式碼實現的是將一個串和mine 物件輸出到一個流，並存入一個檔案：

public class PersonalData implements Serializable {
public int id
public int yearOfBirth;
public float yearlySalary;
}
PersonalData mine = new PersonalData(101, 1956, 46500.00);
FileOutputStream outstream = new FileOutputStream("PersonalData.ser");
ObjectOutputStream out = new ObjectOutputStream(outstream);
out.writeObject("My personal data"); //將一個串寫入流
out.writeObject(mine); //將這個物件寫入流
out.close(); // 清空並關閉流
...

　　一個FileOutputStream物件被建立且傳到一個ObjectOutputStream。當out.writeObject() 被呼叫，這個串和mine 物件被objects are serializ順序加入一個存入檔案PersonalData.ser的位元組對列。

　　您應該注意上述類是實現的java.io.Serializable介面。因為它並未指定要實現的方法，所以Serializable被稱為"tagging interface" ，但是它僅僅"tags"它自己的物件是一個特殊的型別。任一個您希望serialize的物件都應該實現這個介面。這是必須的。否則，用到流技術時將根本不工作。例如，如果您試著去serialize 一個沒有實現這個介面的物件，一個 NotSerializableException將產生。

 

類通過實現 java.io.Serializable 介面以啟用其序列化功能。未實現此介面的類將無法使其任何狀態序列化或反序列化。可序列化類的所有子型別本身都是可序列化的。序列化介面沒有方法或欄位，僅用於標識可序列化的語義。

　　Java的"物件序列化"能讓你將一個實現了Serializable介面的物件轉換成一組byte，這樣日後要用這個物件時候，你就能把這些byte資料恢復出來，並據此重新構建那個物件了。

　　要想序列化物件，你必須先建立一個OutputStream，然後把它嵌進ObjectOutputStream。這時，你就能用writeObject( )方法把物件寫入OutputStream了。

　　writeObject 方法負責寫入特定類的物件的狀態，以便相應的 readObject 方法可以還原它。通過呼叫 out.defaultWriteObject 可以呼叫儲存 Object 的欄位的預設機制。該方法本身不需要涉及屬於其超類或子類的狀態。狀態是通過使用 writeObject 方法或使用 DataOutput 支援的用於基本資料型別的方法將各個欄位寫入 ObjectOutputStream 來儲存的。

　　讀的時候，你得把InputStream嵌到ObjectInputStream裡面，然後再呼叫readObject( )方法。不過這樣讀出來的，只是一個Object的reference，因此在用之前，還得先下傳。readObject 方法負責從流中讀取並還原類欄位。它可以呼叫 in.defaultReadObject 來呼叫預設機制，以還原物件的非靜態和非瞬態欄位。

　　　defaultReadObject 方法使用流中的資訊來分配流中通過當前物件中相應命名欄位儲存的物件的欄位。這用於處理類發展後需要新增新欄位的情形。該方法本身不需要涉及屬於其超類或子類的狀態。狀態是通過使用 writeObject 方法或使用 DataOutput 支援的用於基本資料型別的方法將各個欄位寫入 ObjectOutputStream 來儲存的。

　　看一個列子：

 

　　最後結果如下：

node 0
node 1
node 2
node 3
node 4
node 5
node 6

LiLy is 惠止南國

　　可以看到，在序列化的時候，writeObject與readObject之間的先後順序。readObject將最先write的object read出來。用資料結構的術語來講就姑且稱之為先進先出吧！

　　在序列化時，有幾點要注意的：
　　１：當一個物件被序列化時，只儲存物件的非靜態成員變數，不能儲存任何的成員方法和靜態的成員變數。
　　２：如果一個物件的成員變數是一個物件，那麼這個物件的資料成員也會被儲存。
　　３：如果一個可序列化的物件包含對某個不可序列化的物件的引用，那麼整個序列化操作將會失敗，並且會丟擲一個NotSerializableException。我們可以將這個引用標記為transient，那麼物件仍然可以序列化

　　還有我們對某個物件進行序列化時候，往往對整個物件全部序列化了，比如說類裡有些資料比較敏感，不希望序列化，一個方法可以用transient來標識，另一個方法我們可以在類裡重寫

　　這二個方法！
　　示例：

　　－－(add on 2006/6/28)

參考資料：JDK1.5 API DOC 　孫鑫老師資料

1、實現Serializable回導致釋出的API難以更改，並且使得package-private和private
這兩個本來封裝的較好的咚咚也不能得到保障了
2、Serializable會為每個類生成一個序列號，生成依據是類名、類實現的介面名、
public和protected方法，所以只要你一不小心改了一個已經publish的API，並且沒有自
己定義一個long型別的叫做serialVersionUID的field，哪怕只是新增一個getXX，就會
讓你讀原來的序列化到檔案中的東西讀不出來（不知道為什麼要把方法名算進去？）
3、不用建構函式用Serializable就可以構造物件，看起來不大合理，這被稱為
extralinguistic mechanism，所以當實現Serializable時應該注意維持建構函式中所維
持的那些不變狀態
4、增加了釋出新版本的類時的測試負擔
5、1.4版本後，JavaBeans的持久化採用基於XML的機制，不再需要Serializable
6、設計用來被繼承的類時，儘量不實現Serializable，用來被繼承的interface也不要
繼承Serializable。但是如果父類不實現Serializable介面，子類很難實現它，特別是
對於父類沒有可以訪問的不含引數的建構函式的時候。所以，一旦你決定不實現
Serializable介面並且類被用來繼承的時候記得提供一個無引數的建構函式
7、內部類還是不要實現Serializable好了，除非是static的，(偶也覺得內部類不適合
用來幹這類活的)
8、使用一個自定義的序列化方法
看看下面這個儲存一個雙向連結串列的例子：



public class StringList implements Serializable
{
?private int size = 0;
?private Entry head = null;
?
?private static class Entry implements Serializable
?{
? String data;
? Entry next;
? Entry previous;
?}
?...//Remainder ommitted
}




這樣會導致連結串列的每個元素以及元素之間的關係（雙向連結串列之間的連線）
都儲存下來，更好的方法是提供一個自定義的序列化如下：

//String List with a resonable custom serialized form
class StringList implements Serializable
{
? private transient int size = 0;?????? //!transient
? private transient Entry head = null;? //!transient
?
? //no longer serializable!
? private static class Entry
? {
??? String data;
??? Entry next;
??? Entry previous;
? }
?
? //Appends the specified string to the list
? public void add(String s) {/*...*/};
?
? /**
?? * Serialize this StringList instance
?? * @author yuchifang
?? * @serialData The size of the list (the number of strings
* it contains) is emitted(int), in the proper sequence
?? */
? private void writeObject(ObjectOutputStream s)
throws IOException
? {
??? s.defaultWriteObject();
??? s.writeInt(size);
??? //Write out all elements in the proper order
??? for (Entry e = head; e != null; e = e.next)
????? s.writeObject(e.data);
? }
?
? private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException
? {
??? int numElements = s.readInt();
???
??? //Read in all elements andd insert them in list
??? for (int i = 0; i < numElements; i++)
????? add((String)s.readObject());
? }
? //...remainder omitted
}


9、不管你選擇什麼序列化形式，宣告一個顯式的UID：

private static final long serialVersionUID = randomLongValue;

10、不需要序列化的東西使用transient注掉它吧，別什麼都留著

11、writeObject/readObject過載以完成更好的序列化

readResolve 與 writeReplace過載以完成更好的維護invariant controllers

MarshalByRefObject和Serializable

是的，如果Session要存到資料庫中就必須新增Serializable標記~