Java的序列化機制原理分析

Java的序列化機制原理分析，我們查看下ObjectOutputStream的writeObject方法

1. //final方法，不允許子類覆蓋   
2.     public final void writeObject(Object obj) throws IOException {  
3.         if (enableOverride) { //如果開啟允許序列化被重寫   
4.             writeObjectOverride(obj); //調用子類的序列化重寫方法   
5.             return;  
6.         }  
7.         try {  
8.             writeObject0(obj, false);//調用默認的序列化過程   
9.         } catch (IOException ex) {  
10.             if (depth == 0) {  
11.                 writeFatalException(ex);  
12.             }  
13.             throw ex;  
14.         }  
15.     }  

如果要自定義這個序列化過程，則可以寫一個子類，集成ObjectOutputStream，然後覆蓋其兩個方法

1. protected ObjectOutputStream() throws IOException, SecurityException {  
2.      SecurityManager sm = System.getSecurityManager();  
3.      if (sm != null) {  
4.          sm.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);  
5.      }  
6.      bout = null;  
7.      handles = null;  
8.      subs = null;  
9.      enableOverride = true;  
10.      debugInfoStack = null;  
11.  }  
12. protected void writeObjectOverride(Object obj) throws IOException {  
13.  }  

我們再看下具體的writeObject0方法：

1. private void writeObject0(Object obj, boolean unshared)   
2.         throws IOException   
3.     {  
4.         boolean oldMode = bout.setBlockDataMode(false);  
5.         depth++;  
6.         try {  
7.             // 先對obj實例的類信息進行序列化，   
8.             int h;  
9.             if ((obj = subs.lookup(obj)) == null) {  
10.                 writeNull();  
11.                 return;  
12.             } else if (!unshared && (h = handles.lookup(obj)) != -1) {//可以自定義class類信息的序列化handler   
13.                 writeHandle(h);  
14.                 return;  
15.             } else if (obj instanceof Class) { //類信息序列化   
16.                 writeClass((Class) obj, unshared);  
17.                 return;  
18.             } else if (obj instanceof ObjectStreamClass) { //類信息序列化，此時還包括serialVersionUID   
19.                 writeClassDesc((ObjectStreamClass) obj, unshared);  
20.                 return;  
21.             }  
22.               
23.             // check for replacement object   
24.             //這裡還可以對序列化的類進行替換序列化   
25.             Object orig = obj;  
26.             Class cl = obj.getClass();  
27.             ObjectStreamClass desc;  
28.             for (;;) {  
29.                 // REMIND: skip this check for strings/arrays?   
30.                 Class repCl;  
31.                 desc = ObjectStreamClass.lookup(cl, true);  
32.                 if (!desc.hasWriteReplaceMethod() ||  
33.                     (obj = desc.invokeWriteReplace(obj)) == null ||  
34.                     (repCl = obj.getClass()) == cl)  
35.                 {  
36.                     break;  
37.                 }  
38.                 cl = repCl;  
39.             }  
40.             if (enableReplace) {  
41.                 Object rep = replaceObject(obj);  
42.                 if (rep != obj && rep != null) {  
43.                     cl = rep.getClass();  
44.                     desc = ObjectStreamClass.lookup(cl, true);  
45.                 }  
46.                 obj = rep;  
47.             }  
48.   
49.             // if object replaced, run through original checks a second time   
50.             //如果類信息被替換過，則需要進行第二次處理   
51.             if (obj != orig) {  
52.                 subs.assign(orig, obj);  
53.                 if (obj == null) {  
54.                     writeNull();  
55.                     return;  
56.                 } else if (!unshared && (h = handles.lookup(obj)) != -1) {  
57.                     writeHandle(h);  
58.                     return;  
59.                 } else if (obj instanceof Class) {  
60.                     writeClass((Class) obj, unshared);  
61.                     return;  
62.                 } else if (obj instanceof ObjectStreamClass) {  
63.                     writeClassDesc((ObjectStreamClass) obj, unshared);  
64.                     return;  
65.                 }  
66.             }  
67.   
68.             // remaining cases   
69.             //寫入類實例對象的數據，第一次總是在此執行   
70.             if (obj instanceof String) {  
71.                 writeString((String) obj, unshared);  
72.             } else if (cl.isArray()) {  
73.                 writeArray(obj, desc, unshared);  
74.             } else if (obj instanceof Enum) {  
75.                 writeEnum((Enum) obj, desc, unshared);  
76.             } else if (obj instanceof Serializable) { //我們的bean需要實現Serializable接口，才能進行序列化   
77.                 writeOrdinaryObject(obj, desc, unshared);  
78.             } else {  
79.                 if (extendedDebugInfo) {  
80.                     throw new NotSerializableException(  
81.                         cl.getName() + "\n" + debugInfoStack.toString());  
82.                 } else {  
83.                     throw new NotSerializableException(cl.getName());  
84.                 }      
85.             }  
86.         } finally {  
87.             depth--;  
88.             bout.setBlockDataMode(oldMode);  
89.         }  
90.     }