之前的文章中我們介紹過有關字節流字符流的使用，當時我們對于將一個對象輸出到流中的操作，使用DataOutputStream流將該對象中的每個屬性值逐個輸出到流中，讀出時相反。在我們看來這種行為實在是繁瑣，尤其是在這個對象中屬性值很多的時候。基于此，Java中對象的序列化機制就可以很好的解決這種操作。本篇就簡單的介紹Java對象序列化，主要內容如下：
- 簡潔的代碼實現
- 序列化實現的基本算法
- 兩種特殊的情況
- 自定義序列化機制
- 序列化的版本控制
一、簡潔的代碼實現
在介紹對象序列化的使用方法之前，先看看我們之前是怎么存儲一個對象類型的數據的。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
//簡單定義一個Student類public class Student { private String name; private int age; public Student(){} public Student(String name,int age){ this.name = name; this.age=age; } public void setName(String name){ this.name = name; } public void setAge(int age){ this.age = age; } public String getName(){ return this.name; } public int getAge(){ return this.age; } //重寫toString @Override public String toString(){ return ("my name is:"+this.name+" age is:"+this.age); }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
//main方法實現了將對象寫入文件并讀取出來public static void main(String[] args) throws IOException{ DataOutputStream dot = new DataOutputStream(new FileOutputStream("hello.txt")); Student stuW = new Student("walker",21); //將此對象寫入到文件中 dot.writeUTF(stuW.getName()); dot.writeInt(stuW.getAge()); dot.close(); //將對象從文件中讀出 DataInputStream din = new DataInputStream(new FileInputStream("hello.txt")); Student stuR = new Student(); stuR.setName(din.readUTF()); stuR.setAge(din.readInt()); din.close(); System.out.println(stuR); } |
輸出結果：my name is:walker age is:21
顯然這種代碼書寫是繁瑣的，接下來我們看看，如何使用序列化來完成保存對象的信息。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public static void main(String[] args) throws IOException, ClassNotFoundException { ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("hello.txt")); Student stuW = new Student("walker",21); oos.writeObject(stuW); oos.close(); //從文件中讀取該對象返回 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("hello.txt")); Student stuR = (Student)ois.readObject(); System.out.println(stuR); } |
寫入文件時，只用了一條語句就是writeObject，讀取時也是只用了一條語句readObject。并且Student中的那些set，get方法都用不到了。是不是很簡潔呢？接下來介紹實現細節。
二、實現序列化的基本算法
在這種機制中，每個對象都是對應著唯一的一個序列號，而每個對象在被保存的時候也是根據這個序列號來對應著每個不同的對象，對象序列化就是指利用了每個對象的序列號進行保存和讀取的。首先以寫對象到流中為例，對于每個對象，第一次遇到的時候會將這個對象的基本信息保存到流中，如果當前遇到的對象已經被保存過了，就不會再次保存這些信息，轉而記錄此對象的序列號（因為數據沒必要重復保存）。對于讀的情況，從流中遇到的每個對象，如果第一次遇到，直接輸出，如果讀取到的是某個對象的序列號，就會找到相關聯的對象，輸出。
說明幾點，一個對象要想是可序列化的，就必須實現接口 java.io.Serializable;，這是一個標記接口，不用實現任何的方法。而我們的ObjectOutputStream流，就是一個可以將對象信息轉為字節的流，構造函數如下：
|
1
|
public ObjectOutputStream(OutputStream out) |
也就是所有字節流都可以作為參數傳入，兼容一切字節操作。在這個流中定義了writeObject和readObject方法，實現了序列化對象和反序列化對象。當然，我們也是可以通過在類中實現這兩個方法來自定義序列化機制，具體的后文介紹。此處我們只需要了解整個序列化機制，所有的對象數據只會保存一份，至于相同的對象再次出現，只保存對應的序列號。下面，通過兩個特殊的情況直觀的感受下他的這個基本算法。
三、兩個特殊的實例
先看第一個實例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
public class Student implements Serializable { String name; int age; Teacher t; //另外一個對象類型 public Student(){} public Student(String name,int age,Teacher t){ this.name = name; this.age=age; this.t = t; } public void setName(String name){this.name = name;} public void setAge(int age){this.age = age;} public void setT(Teacher t){this.t = t;} public String getName(){return this.name;} public int getAge(){return this.age;} public Teacher getT(){return this.t;}}public class Teacher implements Serializable { String name; public Teacher(String name){ this.name = name; }}public static void main(String[] args) throws IOException, ClassNotFoundException { Teacher t = new Teacher("li"); Student stu1 = new Student("walker",21,t); Student stu2 = new Student("yam",22,t); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("hello.txt")); oos.writeObject(stu1); oos.writeObject(stu2); ObjectInputStream ois = new ObjectInputStream(new FileInputStream("hello.txt")); Student stuR1 = (Student)ois.readObject(); Student stuR2 = (Student)ois.readObject(); if (stuR1.getT() == stuR2.getT()) System.out.println("相同對象"); } |
結果是很顯而易見的，輸出了相同對象。我們在main函數中定義了兩個student類型對象，他們卻都引用的同一個teacher對象在內部。完成序列化之后，反序列化出來兩個對象，通過比較他們內部的teacher對象是否是同一個實例，可以看出來，在序列化第一個student對象的時候t是被寫入流中的，但是在遇到第二個student對象的teacher對象實例時，發現前面已經寫過了，于是不再寫入流中，只保存對應的序列號作為引用。當然在反序列化的時候，原理類似。這和我們上面介紹的基本算法是一樣的。
下面看第二個特殊實例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
public class Student implements Serializable { String name; Teacher t;}public class Teacher implements Serializable { String name; Student stu;}public static void main(String[] args) throws IOException, ClassNotFoundException { Teacher t = new Teacher(); Student s =new Student(); t.name = "walker"; t.stu = s; s.name = "yam"; s.t = t; ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("hello.txt")); oos.writeObject(t); oos.writeObject(s); oos.close(); ObjectInputStream ois = new ObjectInputStream(new FileInputStream("hello.txt")); Teacher tR = (Teacher)ois.readObject(); Student sR = (Student)ois.readObject(); if(tR == sR.t && sR == tR.stu)System.out.println("ok"); } |
輸出的結果是ok，這個例子可以叫做：循環引用。從結果我們可以看出來，序列化之前兩個對象存在的相互的引用關系，經過序列化之后，兩者之間的這種引用關系是依然存在的。其實按照我們之前介紹的判斷算法來看，首先我們先序列化了teacher對象，因為他內部引用了student的對象，兩者都是第一次遇到，所以將兩者序列化到流中，然后我們去序列化student對象，發現這個對象以及內部的teacher對象都已經被序列化了，于是只保存對應的序列號。讀取的時候根據序列號恢復對象。
四、自定義序列化機制
綜上，我們已經介紹完了基本的序列化與反序列化的知識。但是往往我們會有一些特殊的要求，這種默認的序列化機制雖然已經很完善了，但是有些時候還是不能滿足我們的需求。所以我們看看如何自定義序列化機制。自定義序列化機制中，我們會使用到一個關鍵字，它也是我們之前在看源碼的時候經常遇到的，transient。將字段聲明transient，等于是告訴默認的序列化機制，這個字段你不要給我寫到流中去，我會自己處理的。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public class Student implements Serializable { String name; transient int age; public String toString(){ return this.name + ":" + this.age; }}public static void main(String[] args) throws IOException, ClassNotFoundException { ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("hello.txt")); Student stu = new Student(); stu.name = "walker";stu.age = 21; oos.writeObject(stu); ObjectInputStream ois = new ObjectInputStream(new FileInputStream("hello.txt")); Student stuR = (Student)ois.readObject(); System.out.println(stuR); } |
輸出結果：walker:0
我們不是給age字段賦初始值了么，怎么會是0呢？正如我們上文所說的一樣，被transient修飾的字段不會被寫入流中，自然讀取出來就沒有值，默認是0。下面看看我們怎么自己來序列化這個age。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
//改動過的student類，main方法沒有改動，大家可以往上看public class Student implements Serializable { String name; transient int age; private void writeObject(ObjectOutputStream oos) throws IOException { oos.defaultWriteObject(); oos.writeInt(25); } private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { ois.defaultReadObject(); age = ois.readInt(); } public String toString(){ return this.name + ":" + this.age; }} |
輸出結果：walker:25
結果既不是我么初始化的21，也不是0，而是我們在writeObject方法中寫的25。現在我們一點一點看看每個步驟的意義。首先，要想要實現自定義序列化，就需要在該對象定義的類中實現兩個方法，writeObject和readObject，而且格式必須和上面貼出來的一樣，筆者試過改動方法修飾符，結果導致不能成功序列化。這是因為，Java采用反射機制，檢查該對象所在的類中有沒有實現這兩個方法，沒有的話就使用默認的ObjectOutputStream中的這個方法序列化所有字段，如果有的話就執行你自己實現的這個方法。
接下來，看看這兩個方法實現的細節，先看writeObject方法，參數是ObjectOutputStream 類型的，這個拿到的是我們在main方法中定義的ObjectOutputStream 對象，要不然它怎么知道該把對象寫到那個地方去呢？第一行我們調用的是oos.defaultWriteObject();這個方法實現的功能是，將當前對象中所有沒有被transient修飾的字段寫入流中，第二條語句我們顯式的調用了writeInt方法將age的值寫入流中。讀取的方法類似，此處不再贅述。
五、版本控制
最后我們來看看，序列化過程的的版本控制問題。在我們將一個對象序列化到流中之后，該對象對應的類的結構改變了，如果此時我們再次從流中將之前保存的對象讀取出來，會發生什么？這要分情況來說，如果原類中的字段被刪除了，那從流中輸出的對應的字段將會被忽略。如果原類中增加了某個字段，那新增的字段的值就是默認值。如果字段的類型發生了改變，拋出異常。在Java中每個類都會有一個記錄版本號的變量：static final serivalVersionUID = 115616165165L，此處的值只用于演示并不對應任意某個類。這個版本號是根據該類中的字段等一些屬性信息計算出來的，唯一性較高。每次讀出的時候都會去比較之前和現在的版本號確認是否發生版本不一致情況，如果版本不一致，就會按照上述的情形分別做處理。
對象的序列化就寫完了，如果有什么內容不妥的地方，希望大家指出！
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持服務器之家。
原文鏈接：http://www.jianshu.com/p/9b310533ea6b
