從一個問題開始

假設有這么一個類：

[java] view plaincopy

1. class MyObj {  
2.       
3.     public final int x;  
4.       
5.     public MyObj(int x) {  
6.         this.x = x;  
7.     }  
8.       
9. }  

[java] view plaincopy

1. @Test  
2. public void gson() {  
3.     MyObj obj = new Gson().fromJson("{\"x\":1}", MyObj.class);  
4.     Assert.assertEquals(1, obj.x);  
5. }  

InstanceCreator和ObjectConstructor

經過斷點調試或者閱讀源代碼不難發(fā)現(xiàn)，GSON是使用ObjectConstructor來創(chuàng)建對象實例的，這點從代碼注釋里也能看的出來：

[java] view plaincopy

1. /** 
2.  * Defines a generic object construction factory.  The purpose of this class 
3.  * is to construct a default instance of a class that can be used for object 
4.  * navigation while deserialization from its JSON representation. 
5.  * 
6.  * @author Inderjeet Singh 
7.  * @author Joel Leitch 
8.  */  
9. public interface ObjectConstructor<T> {  
10.   
11.   /** 
12.    * Returns a new instance. 
13.    */  
14.   public T construct();  
15. }  

[java] view plaincopy

1. public <T> ObjectConstructor<T> get(TypeToken<T> typeToken) {  
2.   final Type type = typeToken.getType();  
3.   final Class<? super T> rawType = typeToken.getRawType();  
4.   
5.   // first try an instance creator  
6.   
7.   @SuppressWarnings("unchecked") // types must agree  
8.   final InstanceCreator<T> typeCreator = (InstanceCreator<T>) instanceCreators.get(type);  
9.   if (typeCreator != null) {  
10.     return new ObjectConstructor<T>() {  
11.       public T construct() {  
12.         return typeCreator.createInstance(type);  
13.       }  
14.     };  
15.   }  
16.   
17.   // Next try raw type match for instance creators  
18.   @SuppressWarnings("unchecked") // types must agree  
19.   final InstanceCreator<T> rawTypeCreator =  
20.       (InstanceCreator<T>) instanceCreators.get(rawType);  
21.   if (rawTypeCreator != null) {  
22.     return new ObjectConstructor<T>() {  
23.       public T construct() {  
24.         return rawTypeCreator.createInstance(type);  
25.       }  
26.     };  
27.   }  
28.   
29.   ObjectConstructor<T> defaultConstructor = newDefaultConstructor(rawType);  
30.   if (defaultConstructor != null) {  
31.     return defaultConstructor;  
32.   }  
33.   
34.   ObjectConstructor<T> defaultImplementation = newDefaultImplementationConstructor(type, rawType);  
35.   if (defaultImplementation != null) {  
36.     return defaultImplementation;  
37.   }  
38.   
39.   // finally try unsafe  
40.   return newUnsafeAllocator(type, rawType);  
41. }  

代碼看起來很復雜，但實際上井然有序：

1. 如果我們（通過GsonBuilder）注冊過InstanceCreator，則交給InstanceCreator來創(chuàng)建實例
2. 如果類有默認構造函數(shù)，則通過反射調用默認構造函數(shù)創(chuàng)建實例
3. 如果想要創(chuàng)建List或Map等接口的實例，則走這里
4. 否則交給神秘的UnsafeAllocator來收場
   

第一和第三種情況暫不考慮，下面來分析第二和第四種情況。

有默認構造函數(shù)的情況

按照前面的分析，這種情況GSON是通過調用默認構造函數(shù)來創(chuàng)建對象實例的，讓我們證明這一點：

[java] view plaincopy

1. class MyObj {  
2.       
3.     public final int x;  
4.       
5.     public MyObj() {  
6.         throw new RuntimeException("!!!"); // <---  
7.     }  
8.       
9. }  

[java] view plaincopy

1. @Test(expected = RuntimeException.class) // <---  
2. public void gson() {  
3.     new Gson().fromJson("{\"x\":1}", MyObj.class);  
4. }  

沒有默認構造函數(shù)的情況

還是通過代碼來證明這一點：

[java] view plaincopy

1. class MyObj {  
2.       
3.     public final int x;  
4.       
5.     public MyObj(int x) { // <---  
6.         throw new RuntimeException("!!!");  
7.     }  
8.       
9. }  

[java] view plaincopy

1. @Test  
2. public void gson() {  
3.     MyObj obj = new Gson().fromJson("{\"x\":1}", MyObj.class);  
4.     Assert.assertEquals(1, obj.x);  
5. }  

UnsafeAllocator

現(xiàn)在讓我們一睹UnsafeAllocator的風采：

[java] view plaincopy

1. /** 
2.  * Do sneaky things to allocate objects without invoking their constructors. 
3.  * 
4.  * @author Joel Leitch 
5.  * @author Jesse Wilson 
6.  */  
7. public abstract class UnsafeAllocator {  
8.   public abstract <T> T newInstance(Class<T> c) throws Exception;  
9.   
10.   public static UnsafeAllocator create() {  
11.     // try JVM  
12.     // public class Unsafe {  
13.     //   public Object allocateInstance(Class<?> type);  
14.     // }  
15.     try {  
16.       Class<?> unsafeClass = Class.forName("sun.misc.Unsafe");  
17.       Field f = unsafeClass.getDeclaredField("theUnsafe");  
18.       f.setAccessible(true);  
19.       final Object unsafe = f.get(null);  
20.       final Method allocateInstance = unsafeClass.getMethod("allocateInstance", Class.class);  
21.       return new UnsafeAllocator() {  
22.         @Override  
23.         @SuppressWarnings("unchecked")  
24.         public <T> T newInstance(Class<T> c) throws Exception {  
25.           return (T) allocateInstance.invoke(unsafe, c);  
26.         }  
27.       };  
28.     } catch (Exception ignored) {  
29.     }  
30.   
31.     ...  
32.       
33.     // give up  
34.     return new UnsafeAllocator() {  
35.       @Override  
36.       public <T> T newInstance(Class<T> c) {  
37.         throw new UnsupportedOperationException("Cannot allocate " + c);  
38.       }  
39.     };  
40.   }  
41. }  

去掉反射后，代碼看起來大概是這樣：

那么final字段是怎么處理的？

答案是，通過反射。詳細情況可以參考這個問題，下面我們僅通過代碼來證明這一點：

[java] view plaincopy

1. class MyObj {  
2.       
3.     public final int x;  
4.       
5.     public MyObj(int x) { // <---  
6.         this.x = x;  
7.     }  
8.       
9. }  

[java] view plaincopy

1. @Test  
2. public void setFinal() throws Exception {  
3.     MyObj obj = new MyObj(1);  
4.     Assert.assertEquals(1, obj.x);  
5.       
6.     Field f = obj.getClass().getField("x");  
7.     f.setAccessible(true); // <---  
8.     f.set(obj, 2);  
9.     Assert.assertEquals(2, obj.x);  
10. }  

結論

反序列化時，如果一個類沒有默認構造函數(shù)，那么GSON是通過JDK內部API來創(chuàng)建對象實例的，并且通過反射給final字段賦值。

這種做法通常是很危險的，所以非專業(yè)人士請勿效仿！