一篇文章搞懂對象序列化

本文轉載“柚子”的博客https://www.cnblogs.com/UUUz/p/9877591.html；Ta的博客設計很有創意也很漂亮，像ta表示感謝！

java.io.Serializable淺析

沒有implements Serializable，你就不能通過rmi(包括ejb)提供遠程調用。
serialization 允許你將實現了Serializable接口的對象轉換爲字節序列，這些字節序列可以被完全存儲以備以後重新生成原來的對象。
serialization不但可以在本機做，而且可以經由網絡操作（就是貓小說的RMI）。這個好處是很大的----因爲它自動屏蔽了操作系統的差異，字節順序等。比如，在Window平臺生成一個對象並序列化之，然後通過網絡傳到一臺Unix機器上，然後可以在這臺Unix機器上正確地重構這個對象。
Object serialization主要用來支持2種主要的特性：
1。Java的RMI(remote method invocation).RMI允許象在本機上一樣操作遠程機器上的對象。當發送消息給遠程對象時，就需要用到serializaiton機制來發送參數和接收返回直。
2。Java的JavaBeans. Bean的狀態信息通常是在設計時配置的。Bean的狀態信息必須被存起來，以便當程序運行時能恢復這些狀態信息。這也需要serializaiton機制。
總之如果在網絡的環境下做類傳輸，應該還是implements Serializable。

例子：

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.net.ServerSocket;
import java.net.Socket;

//定義序列化(object)
class Student implements Serializable {
private int sno;
private String sname;

public Student(int sno, String sname) {
this.sno = sno;
this.sname = sname;
}

public int getSno() {
return sno;
}

public void setSno(int sno) {
this.sno = sno;
}

public String getSname() {
return sname;
}

public void setSname(String sname) {
this.sname = sname;
}

@Override
public String toString() {
return "學號:" + sno + ";姓名:" + sname;
}

}
//(object)的反序列化過程
class MyClient extends Thread {
@Override
public void run() {
try {
Socket s = new Socket("localhost", 9999);
ObjectInputStream ois = new ObjectInputStream(s.getInputStream());
Student stu = (Student) ois.readObject();
System.out.println("客戶端程序收到服務器端程序傳輸過來的學生對象>> " + stu);
ois.close();
s.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//(object)的序列化過程
class MyServer extends Thread {

@Override
public void run() {
try {
ServerSocket ss = new ServerSocket(9999);
Socket s = ss.accept();
ObjectOutputStream ops = new ObjectOutputStream(s.getOutputStream());
Student stu = new Student(1, "趙本山");
ops.writeObject(stu);
ops.close();
s.close();
ss.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
//測試
public class TestTransfer {
public static void main(String[] args) {
new MyServer().start();
new MyClient().start();
}
}

參照這個例子就會很好的理解Serializable接口的用法和作用了。

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

　Java API中java.io.Serializable接口源碼：

1 public interface Serializable {
2 }

　　類通過實現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 來保存的。

　　在序列化時，有幾點要注意的：

　　１：當一個對象被序列化時，只保存對象的非靜態成員變量（包括聲明爲private的變量），不能保存任何的成員方法和靜態的成員變量。

　　２：如果一個對象的成員變量是一個對象，那麼這個對象的數據成員也會被序列化。

　　３：如果一個可序列化的對象包含對某個不可序列化的對象的引用，那麼整個序列化操作將會失敗，並且會拋出一個NotSerializableException。我們可以將這個引用標記爲transient，那麼對象仍然可以序列化。

　　1、序列化是幹什麼的？

　　簡單說就是爲了保存在內存中的各種對象的狀態，並且可以把保存的對象狀態再讀出來。雖然你可以用你自己的各種各樣的方法來保存Object States，但是Java給你提供一種應該比你自己好的保存對象狀態的機制,那就是序列化。

　　2、什麼情況下需要序列化

　　a）當你想把的內存中的對象保存到一個文件中或者數據庫中時候；
　　b）當你想用套接字在網絡上傳送對象的時候；
　　c）當你想通過RMI傳輸對象的時候；

　　3、當對一個對象實現序列化時，究竟發生了什麼？

　　在沒有序列化前，每個保存在堆（Heap）中的對象都有相應的狀態（state），即實例變量（instance ariable）比如：

1 Foo myFoo = new Foo();
2 myFoo .setWidth(37);
3 myFoo.setHeight(70);

　　當通過下面的代碼序列化之後，MyFoo對象中的width和Height實例變量的值（37，70）都被保存到foo.ser文件中，這樣以後又可以把它從文件中讀出來，重新在堆中創建原來的對象。當然保存時候不僅僅是保存對象的實例變量的值，JVM還要保存一些小量信息，比如類的類型等以便恢復原來的對象。

1 FileOutputStream fs = new FileOutputStream("foo.ser");
2 ObjectOutputStream os = new ObjectOutputStream(fs);
3 os.writeObject(myFoo);

　　4、實現序列化（保存到一個文件）的步驟

　　a）Make a FileOutputStream

　　java 代碼
　　FileOutputStream fs = new FileOutputStream("foo.ser");

　　b）Make a ObjectOutputStream

　　java 代碼
　　ObjectOutputStream os = new ObjectOutputStream(fs);

　　c）write the object

　　java 代碼
　　os.writeObject(myObject1);
　　os.writeObject(myObject2);
　　os.writeObject(myObject3);

　　d) close the ObjectOutputStream

　　java 代碼
　　os.close();

　　5、舉例說明

 1 public class Box implements Serializable {
 2     private static final long serialVersionUID = -3450064362986273896L;
 3     
 4     private int width;
 5     private int height;
 6     
 7     public static void main(String[] args) {
 8         Box myBox=new Box();
 9         myBox.setWidth(50);
10         myBox.setHeight(30);
11         try {
12             FileOutputStream fs=new FileOutputStream("F:\\foo.ser");
13             ObjectOutputStream os=new ObjectOutputStream(fs);
14             os.writeObject(myBox);
15             os.close();
16             FileInputStream fi=new FileInputStream("F:\\foo.ser");
17             ObjectInputStream oi=new ObjectInputStream(fi);
18             Box box=(Box)oi.readObject();
19             oi.close();
20             System.out.println(box.height+","+box.width);
21         } catch (Exception e) {
22             e.printStackTrace();
23         }
24     }
25     
26     public int getWidth() {
27         return width;
28     }
29     public void setWidth(int width) {
30         this.width = width;
31     }
32     public int getHeight() {
33         return height;
34     }
35     public void setHeight(int height) {
36         this.height = height;
37     }
38 }

　　6、相關注意事項

　　a）當一個父類實現序列化，子類自動實現序列化，不需要顯式實現Serializable接口；
　　b）當一個對象的實例變量引用其他對象，序列化該對象時也把引用對象進行序列化；
　　c）並非所有的對象都可以序列化，至於爲什麼不可以，有很多原因了,比如：

　　1.安全方面的原因，比如一個對象擁有private，public等field，對於一個要傳輸的對象，比如寫到文件，或者進行rmi傳輸等等，在序列化進行傳輸的過程中，這個對象的private等域是不受保護的。
　　2. 資源分配方面的原因，比如socket，thread類，如果可以序列化，進行傳輸或者保存，也無法對他們進行重新的資源分配，而且，也是沒有必要這樣實現。

　　serialVersionUID

　　序列化運行時使用一個稱爲 serialVersionUID 的版本號與每個可序列化類相關聯，該序列號在反序列化過程中用於驗證序列化對象的發送者和接收者是否爲該對象加載了與序列化兼容的類。如果接收者加載的該對象的類的 serialVersionUID 與對應的發送者的類的版本號不同，則反序列化將會導致 InvalidClassException。可序列化類可以通過聲明名爲 "serialVersionUID" 的字段（該字段必須是靜態 (static)、最終 (final) 的 long 型字段）顯式聲明其自己的 serialVersionUID：

 ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;

　　如果可序列化類未顯式聲明 serialVersionUID，則序列化運行時將基於該類的各個方面計算該類的默認 serialVersionUID 值，如“Java(TM) 對象序列化規範”中所述。不過，強烈建議 所有可序列化類都顯式聲明 serialVersionUID 值，原因是計算默認的 serialVersionUID 對類的詳細信息具有較高的敏感性，根據編譯器實現的不同可能千差萬別，這樣在反序列化過程中可能會導致意外的 InvalidClassException。因此，爲保證 serialVersionUID 值跨不同 java 編譯器實現的一致性，序列化類必須聲明一個明確的 serialVersionUID 值。還強烈建議使用 private 修飾符顯示聲明 serialVersionUID（如果可能），原因是這種聲明僅應用於直接聲明類 -- serialVersionUID 字段作爲繼承成員沒有用處。數組類不能聲明一個明確的 serialVersionUID，因此它們總是具有默認的計算值，但是數組類沒有匹配 serialVersionUID 值的要求。

再次聲明：本文轉載“柚子”的博客https://www.cnblogs.com/UUUz/p/9877591.html