詳解Java編程中對象的序列化。本站提示廣大學習愛好者：（詳解Java編程中對象的序列化）文章只能為提供參考，不一定能成為您想要的結果。以下是詳解Java編程中對象的序列化正文
1. 甚麼是Java對象序列化
Java平台許可我們在內存中創立可復用的Java對象，但普通情形下，只要當JVM處於運轉時，這些對象才能夠存在，即，這些對象的性命周期不會比JVM的性命周期更長。但在實際運用中，便可能請求在JVM停滯運轉以後可以或許保留(耐久化)指定的對象，並在未來從新讀取被保留的對象。Java對象序列化就可以夠贊助我們完成該功效。
應用Java對象序列化，在保留對象時，會把其狀況保留為一組字節，在將來，再將這些字節組裝成對象。必需留意地是，對象序列化保留的是對象的"狀況"，即它的成員變量。由此可知，對象序列化不會存眷類中的靜態變量。
除在耐久化對象時會用到對象序列化以外，當應用RMI(長途辦法挪用)，或在收集中傳遞對象時，都邑用到對象序列化。Java序列化API為處置對象序列化供給了一個尺度機制，該API簡略易用，在本文的後續章節中將會陸續講到。
2. 簡略示例
在Java中，只需一個類完成了java.io.Serializable接口，那末它便可以被序列化。此處將創立一個可序列化的類Person，本文中的一切示例將環繞著該類或其修正版。
Gender類，是一個列舉類型，表現性別
public enum Gender {
MALE, FEMALE
}
假如熟習Java列舉類型的話，應當曉得每一個列舉類型都邑默許繼續類java.lang.Enum，而該類完成了Serializable接口，所以列舉類型對象都是默許可以被序列化的。
Person類，完成了Serializable接口，它包括三個字段：name，String類型；age，Integer類型；gender，Gender類型。別的，還重寫該類的toString()辦法，以便利打印Person實例中的內容。
public class Person implements Serializable {
private String name = null;
private Integer age = null;
private Gender gender = null;
public Person() {
System.out.println("none-arg constructor");
}
public Person(String name, Integer age, Gender gender) {
System.out.println("arg constructor");
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Gender getGender() {
return gender;
}
public void setGender(Gender gender) {
this.gender = gender;
}
@Override
public String toString() {
return "[" + name + ", " + age + ", " + gender + "]";
}
}
SimpleSerial，是一個簡略的序列化法式，它先將一個Person對象保留到文件person.out中，然後再從該文件中讀出被存儲的Person對象，並打印該對象。
public class SimpleSerial {
public static void main(String[] args) throws Exception {
File file = new File("person.out");
ObjectOutputStream oout = new ObjectOutputStream(new FileOutputStream(file));
Person person = new Person("John", 101, Gender.MALE);
oout.writeObject(person);
oout.close();
ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));
Object newPerson = oin.readObject(); // 沒有強迫轉換到Person類型
oin.close();
System.out.println(newPerson);
}
}
上述法式的輸入的成果為：
arg constructor [John, 31, MALE]
此時必需留意的是，當從新讀取被保留的Person對象時，並沒有挪用Person的任何結構器，看起來就像是直接應用字節將Person對象復原出來的。
當Person對象被保留到person.out文件中以後，我們可以在其它處所去讀取該文件以復原對象，但必需確保該讀取法式的CLASSPATH中包括有Person.class(哪怕在讀取Person對象時並沒有顯示地應用Person類，如上例所示)，不然會拋出ClassNotFoundException。
3. Serializable的感化
為何一個類完成了Serializable接口，它便可以被序列化呢？在上節的示例中，應用ObjectOutputStream來耐久化對象，在該類中有以下代碼：
private void writeObject0(Object obj, boolean unshared) throws IOException {
...
if (obj instanceof String) {
writeString((String) obj, unshared);
} else if (cl.isArray()) {
writeArray(obj, desc, unshared);
} else if (obj instanceof Enum) {
writeEnum((Enum) obj, desc, unshared);
} else if (obj instanceof Serializable) {
writeOrdinaryObject(obj, desc, unshared);
} else {
if (extendedDebugInfo) {
throw new NotSerializableException(cl.getName() + "\n"
+ debugInfoStack.toString());
} else {
throw new NotSerializableException(cl.getName());
}
}
...
}
從上述代碼可知，假如被寫對象的類型是String，或數組，或Enum，或Serializable，那末便可以對該對象停止序列化，不然將拋出NotSerializableException。
4. 默許序列化機制
假如僅僅只是讓某個類完成Serializable接口，而沒有其它任何處置的話，則就是應用默許序列化機制。應用默許機制，在序列化對象時，不只會序列化以後對象自己，還會對該對象援用的其它對象也停止序列化，異樣地，這些其它對象援用的別的對象也將被序列化，以此類推。所以，假如一個對象包括的成員變量是容器類對象，而這些容器所含有的元素也是容器類對象，那末這個序列化的進程就會較龐雜，開支也較年夜。
5. 影響序列化
在實際運用中，有些時刻不克不及應用默許序列化機制。好比，願望在序列化進程中疏忽失落敏感數據，或許簡化序列化進程。上面將引見若干影響序列化的辦法。
5.1 transient症結字
當某個字段被聲明為transient後，默許序列化機制就會疏忽該字段。此處將Person類中的age字段聲明為transient，以下所示，
public class Person implements Serializable {
...
transient private Integer age = null;
...
}
再履行SimpleSerial運用法式，會有以下輸入：
arg constructor [John, null, MALE]
可見，age字段未被序列化。
5.2 writeObject()辦法與readObject()辦法
關於上述已被聲明為transitive的字段age，除將transitive症結字去失落以外，能否還有其它辦法能使它再次可被序列化？辦法之一就是在Person類中添加兩個辦法：writeObject()與readObject()，以下所示：
public class Person implements Serializable {
...
transient private Integer age = null;
...
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(age);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
age = in.readInt();
}
}
在writeObject()辦法中會先挪用ObjectOutputStream中的defaultWriteObject()辦法，該辦法會履行默許的序列化機制，如5.1節所述，此時會疏忽失落age字段。然後再挪用writeInt()辦法顯示地將age字段寫入到ObjectOutputStream中。readObject()的感化則是針對對象的讀取，其道理與writeObject()辦法雷同。再次履行SimpleSerial運用法式，則又會有以下輸入：
arg constructor [John, 31, MALE]
必需留意地是，writeObject()與readObject()都是private辦法，那末它們是若何被挪用的呢？毫無疑問，是應用反射。概況可以看看ObjectOutputStream中的writeSerialData辦法，和ObjectInputStream中的readSerialData辦法。
5.3 Externalizable接口
不管是應用transient症結字，照樣應用writeObject()和readObject()辦法，其實都是基於Serializable接口的序列化。JDK中供給了另外一個序列化接口--Externalizable，應用該接口以後，之前基於Serializable接口的序列化機制就將掉效。此時將Person類作以下修正，
public class Person implements Externalizable {
private String name = null;
transient private Integer age = null;
private Gender gender = null;
public Person() {
System.out.println("none-arg constructor");
}
public Person(String name, Integer age, Gender gender) {
System.out.println("arg constructor");
this.name = name;
this.age = age;
this.gender = gender;
}
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(age);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
age = in.readInt();
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
}
...
}
此時再履行SimpleSerial法式以後會獲得以下成果：
arg constructor none-arg constructor [null, null, null]
從該成果，一方面，可以看出Person對象中任何一個字段都沒有被序列化。另外一方面，假如仔細的話，還可以發明這此順序列化進程挪用了Person類的無參結構器。
Externalizable繼續於Serializable，當應用該接口時，序列化的細節須要由法式員去完成。如上所示的代碼，因為writeExternal()與readExternal()辦法未作任何處置，那末該序列化行動將不會保留/讀取任何一個字段。這也就是為何輸入成果中一切字段的值均為空。
別的，應用Externalizable停止序列化時，當讀取對象時，會挪用被序列化類的無參結構器去創立一個新的對象，然後再將被保留對象的字段的值分離填充到新對象中。這就是為何在此順序列化進程中Person類的無參結構器會被挪用。因為這個緣由，完成Externalizable接口的類必需要供給一個無參的結構器，且它的拜訪權限為public。
對上述Person類停止進一步的修正，使其可以或許對name與age字段停止序列化，但疏忽失落gender字段，以下代碼所示：
public class Person implements Externalizable {
private String name = null;
transient private Integer age = null;
private Gender gender = null;
public Person() {
System.out.println("none-arg constructor");
}
public Person(String name, Integer age, Gender gender) {
System.out.println("arg constructor");
this.name = name;
this.age = age;
this.gender = gender;
}
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(age);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
age = in.readInt();
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(name);
out.writeInt(age);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
name = (String) in.readObject();
age = in.readInt();
}
...
}
履行SimpleSerial以後會有以下成果：
arg constructor none-arg constructor [John, 31, null]
5.4 readResolve()辦法
當我們應用Singleton形式時，應當是希冀某個類的實例應當是獨一的，但假如該類是可序列化的，那末情形能夠略有分歧。此時對第2節應用的Person類停止修正，使其完成Singleton形式，以下所示：
public class Person implements Serializable {
private static class InstanceHolder {
private static final Person instatnce = new Person("John", 31, Gender.MALE);
}
public static Person getInstance() {
return InstanceHolder.instatnce;
}
private String name = null;
private Integer age = null;
private Gender gender = null;
private Person() {
System.out.println("none-arg constructor");
}
private Person(String name, Integer age, Gender gender) {
System.out.println("arg constructor");
this.name = name;
this.age = age;
this.gender = gender;
}
...
}
同時要修正SimpleSerial運用，使得可以或許保留/獲得上述單例對象，並停止對象相等性比擬，以下代碼所示：
public class SimpleSerial {
public static void main(String[] args) throws Exception {
File file = new File("person.out");
ObjectOutputStream oout = new ObjectOutputStream(new FileOutputStream(file));
oout.writeObject(Person.getInstance()); // 保留單例對象
oout.close();
ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));
Object newPerson = oin.readObject();
oin.close();
System.out.println(newPerson);
System.out.println(Person.getInstance() == newPerson); // 將獲得的對象與Person類中的單例對象停止相等性比擬
}
}
履行上述運用法式後會獲得以下成果：
arg constructor [John, 31, MALE] false
值得留意的是，從文件person.out中獲得的Person對象與Person類中的單例對象其實不相等。為了能在序列化進程仍能堅持單例的特征，可以在Person類中添加一個readResolve()辦法，在該辦法中直接前往Person的單例對象，以下所示：
public class Person implements Serializable {
private static class InstanceHolder {
private static final Person instatnce = new Person("John", 31, Gender.MALE);
}
public static Person getInstance() {
return InstanceHolder.instatnce;
}
private String name = null;
private Integer age = null;
private Gender gender = null;
private Person() {
System.out.println("none-arg constructor");
}
private Person(String name, Integer age, Gender gender) {
System.out.println("arg constructor");
this.name = name;
this.age = age;
this.gender = gender;
}
private Object readResolve() throws ObjectStreamException {
return InstanceHolder.instatnce;
}
...
}
再次履行本節的SimpleSerial運用後將以下輸入：
arg constructor [John, 31, MALE] true
不管是完成Serializable接口，或是Externalizable接口，當從I/O流中讀取對象時，readResolve()辦法都邑被挪用到。現實上就是用readResolve()中前往的對象直代替換在反序列化進程中創立的對象。
6.一些高等用法
該說的都在正文中說完了。直接給法式吧。
package test.javaPuzzler.p5;
import java.io.*;
import java.io.ObjectInputStream.GetField;
import java.io.ObjectOutputStream.PutField;
// 一個類完成Serializable來注解本身可以被序列化；
// 有一點須要特殊留意的是：
// 假如子類完成了Serializable，而父類沒有，則父類不會被序列化；
public class SerializableObject implements Serializable {
// 生成的序列化版本號會由於編譯情況，聲明的類名，成員稱號和數目的變更而分歧；
// 也就是說這個版本號必定水平上記載著類的界說性的信息，假如類的界說變更了，最好從新生成版本號；
// 假如新的代碼應用了舊的版本號，則在反序列化的時刻，可以兼容讀取舊類的字節碼而不會報錯；
private static final long serialVersionUID = 9038542591452547920L;
public String name;
public String password;
// 假如你不願望某個非靜態成員被序列化，可以用transient來潤飾它；
public transient int age;
// 靜態成員不會被序列化，由於序列化保留的是實例的狀況信息，而靜態成員是類的狀況信息；
public static int version = 1;
public SerializableObject(String name, String password) {
this.name = name;
this.password = password;
}
// 每一個類可以寫一個writeObject辦法，這個辦法將會擔任該類本身的序列化進程；
// 好比關於敏感信息如password，可以加密以後再序列化；
// 這個進程須要用到PutField，它可以指定哪些域會被序列化，怎樣序列化(好比加密);
// 假如沒有界說這個辦法，將會挪用ObjectOutputStream 的 defaultWriteObject；
// 你可以正文失落readObject辦法，然後運轉測試用例來測試暗碼能否被加密；
private void writeObject(ObjectOutputStream out) throws IOException {
PutField putFields = out.putFields();
putFields.put("name", name);
// 模仿加密暗碼
putFields.put("password", "thePassword:" + password);
out.writeFields();
}
// 每一個類可以寫一個readObject辦法，該辦法擔任該類本身的反序列化進程；
// 好比對序列化時加密後的暗碼解密；
// 這個進程須要用到GetField，他可以詳細地讀取每一個域；或履行解密舉措等等；
// 假如沒有界說這個辦法，將會挪用ObjectInputStream 的 defaultReadObject；
private void readObject(ObjectInputStream in)
throws ClassNotFoundException, IOException {
GetField readFields = in.readFields();
// 讀取到成員的值以後，直接賦給該域，即完成該域的反序列化；
name = (String) readFields.get("name", "defaultName");
// 模仿解密暗碼
String encPassword = (String) readFields.get("password",
"thePassword:defaultValue");
password = encPassword.split(":")[1];
}
// 序列化
// 重要用到ObjectOutputStream；
public void save() throws IOException {
FileOutputStream fout = new FileOutputStream("e:\\obj");
ObjectOutputStream oout = new ObjectOutputStream(fout);
oout.writeObject(this);
oout.close();
fout.close();
}
// 反序列化
// 重要用到ObjectInputStream
public static SerializableObject load() throws IOException,
ClassNotFoundException {
FileInputStream fin = new FileInputStream("e:\\obj");
ObjectInputStream oin = new ObjectInputStream(fin);
Object o = oin.readObject();
return (SerializableObject) o;
}
@Override
public String toString() {
return "name: " + name + ", password: " + password;
}
// 測試用例
public static void main(String[] args) throws IOException,
ClassNotFoundException {
SerializableObject so = new SerializableObject(
"http://blog.csdn.net/sunxing007", "123456");
so.save();
System.out.println(so);
System.out.println(SerializableObject.load());
}
}
序列化會對單例形式晦氣, 由於可以經由過程反序列化而損壞單例. 這個時刻就要請出readResolve這個辦法了. 好比上面的法式:
public class Dog extends Exception {
//private static final long serialVersionUID = -7156412195888553079L;
public static final Dog INSTANCE = new Dog();
private Dog() { }
public String toString() {
return "Woof";
}
// 經由過程readResolve, 包管反序列化的時刻能完整自立地處置前往對象.
private Object readResolve(){
return INSTANCE;
}
public static void main(String[] args) throws IOException, ClassNotFoundException{
Dog d = Dog.INSTANCE;
ByteArrayOutputStream bro = new ByteArrayOutputStream();
ObjectOutputStream oout = new ObjectOutputStream(bro);
oout.writeObject(d);
ObjectInputStream oin = new ObjectInputStream(new ByteArrayInputStream(bro.toByteArray()));
Dog d1 = (Dog)oin.readObject();
System.out.println(d1==d);
}
}
