一、為什么要序列化
java允許我們在內存中創建可復用的對象，當JVM正常運行時，這些對象才存在，這些對象的生命周期不會比JVM的生命周期更長。當我們需要永久化保存這些對象時，就需要使用序列化來將對象轉化成二進制信息存儲起來，方便隨時調用。
二、java如何實現序列化
java實現序列化的方式很簡單，只需要將序列化的類實現Serializable接口即可；不實現Serializable接口的類在調用writeObject()方式時會報錯NotSerializableException；具體的原因看writeObject()源碼：
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());
}
}
在進行序列化操作時，會判斷要被序列化的類是否是Enum、Array和Serializable類型，如果不是則直接拋出NotSerializableException。
三、通過Serializable實現序列化需要注意的幾個問題
1.序列化 ID 的問題
虛擬機是否允許反序列化，不僅取決于類路徑和功能代碼是否一致，一個非常重要的一點是兩個類的序列化 ID 是否一致；
public class Man implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
private String address;
public static int height = 185;
transient private String hobby;
//省略getter(),setter()方法
}
寫個main()方法測試一下：
Man man = new Man();
man.setName("ymz");
man.setAddress("屋子科");
man.setAge(18);
File file = new File("test01.txt");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(man);
oos.flush();
oos.close();
在系列化之后改變Man類的序列化ID，
private static final long serialVersionUID = 2L;
然后反序列化，看結果:
//改變序列ID之后再讀取會報錯
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test01.txt"));
Man man = (Man)ois.readObject();
ois.close();
System.out.println(man.getName());
具體的報錯信息：
Exception in thread "main" java.io.InvalidClassException: cn.ymz.serialization.Man; local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 2
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:621)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1623)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1518)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1774)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)
at cn.ymz.serialization.TestSeria01.main(TestSeria01.java:23)
2.靜態變量的序列化
直接看代碼：
//先寫入文件,當前height的值是185
Man man = new Man();
man.setName("ymz");
man.setAddress("屋子科");
man.setAge(18);
File file = new File("test02.txt");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(man);
oos.flush();
oos.close();
//改變height的值
Man.height = 100;
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test02.txt"));
Man man2 = (Man)ois.readObject();
ois.close();
System.out.println(man2.getHeight());
height的初始值是185，在序列化之后，改變height的值，看結果會是多少：
100
height的值變了！說明讀取的不是文件中的內容，讀的是JVM中Man類的height屬性；序列化并不保存靜態變量。
3.transient關鍵字的作用
Man man = new Man();
man.setName("ymz");
man.setAddress("屋子科");
man.setAge(18);
man.setHobby("eat");
File file = new File("test03.txt");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(man);
oos.flush();
oos.close();
//讀取被transient修飾的屬性
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test03.txt"));
Man man2 = (Man)ois.readObject();
ois.close();
System.out.println(man2.getHobby());
輸出的結果為：null;
被transient修飾的屬性不會被序列化，在反序列化的時候會給該屬性一個默認值，int默認給0，string默認給null。
4.重寫writeObject()與readObject()方法可以實現對某些屬性的特殊處理
重寫writeObject()與readObject()方法后，ObjectOutputStream會通過反射調用類中重寫的方法：
private void writeObject(ObjectOutputStream oos){
try {
ObjectOutputStream.PutField putFields = oos.putFields();
System.out.println("原地址："+address);
address = "****"+address+"****";
putFields.put("address",address);
System.out.println("加密后的地址："+address);
oos.writeFields();
} catch (Exception e) {
e.printStackTrace();
}
}
private void readObject(ObjectInputStream ois){
try {
ObjectInputStream.GetField getField = ois.readFields();
Object obj = getField.get("address","");
System.out.println("加密后獲取到的地址："+obj);
obj = String.valueOf(obj).replace("*","");
System.out.println("解密后的地址："+obj);
address = obj.toString();
} catch (Exception e) {
e.printStackTrace();
}
}
測試一下：
Man man = new Man();
man.setAddress("屋子科");
File file = new File("test04.txt");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(man);
oos.flush();
oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test04.txt"));
Man man2 = (Man)ois.readObject();
ois.close();
System.out.println(man2.getAddress());
輸出結果為：
原地址：屋子科
加密后的地址：****屋子科****
加密后獲取到的地址：****屋子科****
解密后的地址：屋子科
屋子科
5.序列化存儲規則
將一個類連續兩次寫入同一個文件，看文件的大小變化；再連續讀取兩次，看是否得到同一個對象：
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream("result.obj"));
Man test = new Man();
//試圖將對象兩次寫入文件
out.writeObject(test);
out.flush();
System.out.println(new File("result.obj").length());
out.writeObject(test);
out.close();
System.out.println(new File("result.obj").length());
ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
"result.obj"));
//從文件依次讀出兩個文件
Man t1 = (Man) oin.readObject();
Man t2 = (Man) oin.readObject();
oin.close();
//判斷兩個引用是否指向同一個對象
System.out.println(t1 == t2);
結果如下：
100
105
true
Java 序列化機制為了節省磁盤空間，具有特定的存儲規則，當寫入文件的為同一對象時，并不會再將對象的內容進行存儲，而只是再次存儲一份引用，上面增加的 5 字節的存儲空間就是新增引用和一些控制信息的空間。反序列化時，恢復引用關系，使得 t1 和 t2 指向唯一的對象，二者相等，輸出 true。該存儲規則極大的節省了存儲空間。
6.序列化特性分析
在連續兩次序列化同一對象中間，改變對象的屬性值，然后看對象的值是否被改寫：
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("result.obj"));
Man man = new Man();
man.setAge(1);
out.writeObject(man);
out.flush();
man.setAge(2);
out.writeObject(man);
out.close();
ObjectInputStream oin = new ObjectInputStream(new FileInputStream("result.obj"));
Man t1 = (Man) oin.readObject();
Man t2 = (Man) oin.readObject();
System.out.println(t1.getAge());
System.out.println(t2.getAge());
輸出結果為：
1
1
結果兩個輸出的都是 1。
原因就是第一次寫入對象以后，第二次再試圖寫的時候，虛擬機根據引用關系知道已經有一個相同對象已經寫入文件，因此只保存第二次寫的引用，所以讀取時，都是第一次保存的對象。
