from:http://hittyt.iteye.com/blog/1691772

Hessian反序列化問題

眾所周知，Hessian框架提供的序列化方式，在性能上要優于Java自己的序列化方式。他將對象序列化，生成的字節數組的數量要相對于Java自帶的序列化方式要更簡潔。

目前公司的一個項目中，有RPC調用的需要，這里我們使用了公司自己的開源RPC框架Dubbo作為遠程調用框架，進行業務方法的調用和對象的序列化。這里，我們沒有對Dubbo做出特殊配置，Dubbo在Remoting層組件默認的序列化方式就是采用的Hessian協議處理。但是在真正部署測試時，走到需要遠程調用的方式時，報出了一下異常（只截取了最核心的異常堆棧）：

 

Java代碼  收藏代碼
  1. Caused by: com.alibaba.com.caucho.hessian.io.HessianProtocolException: 'com.alibaba.ais.bdc.person.vo.CountVO$CountObject' could not be instantiated  
  2.     at com.alibaba.com.caucho.hessian.io.JavaDeserializer.instantiate(JavaDeserializer.java:275)  
  3.     at com.alibaba.com.caucho.hessian.io.JavaDeserializer.readObject(JavaDeserializer.java:155)  
  4.     at com.alibaba.com.caucho.hessian.io.SerializerFactory.readObject(SerializerFactory.java:397)  
  5.     at com.alibaba.com.caucho.hessian.io.Hessian2Input.readObjectInstance(Hessian2Input.java:2070)  
  6.     at com.alibaba.com.caucho.hessian.io.Hessian2Input.readObject(Hessian2Input.java:2005)  
  7.     at com.alibaba.com.caucho.hessian.io.Hessian2Input.readObject(Hessian2Input.java:1990)  
  8.     at com.alibaba.com.caucho.hessian.io.CollectionDeserializer.readLengthList(CollectionDeserializer.java:93)  
  9.     at com.alibaba.com.caucho.hessian.io.Hessian2Input.readObject(Hessian2Input.java:1678)  
  10.     at com.alibaba.com.caucho.hessian.io.JavaDeserializer$ObjectFieldDeserializer.deserialize(JavaDeserializer.java:396)  
  11.     ... 42 more  
  12. Caused by: java.lang.reflect.InvocationTargetException  
  13.     at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)  
  14.     at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39)  
  15.     at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27)  
  16.     at java.lang.reflect.Constructor.newInstance(Constructor.java:513)  
  17.     at com.alibaba.com.caucho.hessian.io.JavaDeserializer.instantiate(JavaDeserializer.java:271)  
  18.     ... 50 more  
  19. Caused by: java.lang.IllegalArgumentException: [Assertion failed] - this argument is required; it must not be null  
  20.     at org.springframework.util.Assert.notNull(Assert.java:112)  
  21.     at org.springframework.util.Assert.notNull(Assert.java:123)  
  22.     at com.alibaba.ais.bdc.person.vo.CountVO$CountObject.<init>(CountVO.java:101)  
  23.     ... 55 more  

從最下面的異常信息可以看出，CountObject這個內部類在對象初始化時，報了參數校驗的失敗。這個看一下CountObject的出問題的構造函數就一目了然了：

Java代碼  收藏代碼
  1. public CountObject(SimplePerson simplePerson, String imagePrefix){  
  2.     Assert.notNull(simplePerson);  
  3.     if (StringUtils.isEmpty(imagePrefix)) {  
  4.         throw new IllegalArgumentException("imagePrefix [" + imagePrefix + "] is meaningless.");  
  5.     }  
  6.     this.id = simplePerson.getEmployeeId();  
  7.     this.name = simplePerson.getRealName();  
  8.     this.imagePath = StringUtils.isEmpty(simplePerson.getImagePathSuffix()) ? null : imagePrefix  
  9.                                                                                      + simplePerson.getImagePathSuffix();  
  10. }  

現在在構造函數的第一行的Assert就失敗了。可是哪里調用這個構造函數導致失敗呢？繼續網上翻看異常堆棧給出的信息。可以看出在JavaDeserializer.instantiate中拋出了HessianProtocolException異常。進去看一下Hessian這塊的源碼如下：

Java代碼  收藏代碼
  1. protected Object instantiate()  
  2.   throws Exception  
  3. {  
  4.   try {  
  5.     if (_constructor != null)  
  6. eturn _constructor.newInstance(_constructorArgs);  
  7.     else  
  8. eturn _type.newInstance();  
  9.   } catch (Exception e) {  
  10.     throw new HessianProtocolException("'" + _type.getName() + "' could not be instantiated", e);  
  11.   }  
  12. }  

這里結合上面的異常堆棧可以知道，上面出問題的關鍵是_constructor和_constructorArgs。這兩個東東又到底是啥呢？繼續來看代碼：

Java代碼  收藏代碼
  1.  public JavaDeserializer(Class cl)  
  2.  {  
  3.    _type = cl;  
  4.    _fieldMap = getFieldMap(cl);  
  5.   
  6.    _readResolve = getReadResolve(cl);  
  7.   
  8.    if (_readResolve != null) {  
  9.      _readResolve.setAccessible(true);  
  10.    }  
  11.   
  12.    Constructor []constructors = cl.getDeclaredConstructors();  
  13.    long bestCost = Long.MAX_VALUE;  
  14.   
  15.    for (int i = 0; i < constructors.length; i++) {  
  16.      Class []param = constructors[i].getParameterTypes();  
  17.      long cost = 0;  
  18.   
  19.      for (int j = 0; j < param.length; j++) {  
  20. cost = 4 * cost;  
  21.   
  22. if (Object.class.equals(param[j]))  
  23.   cost += 1;  
  24. else if (String.class.equals(param[j]))  
  25.   cost += 2;  
  26. else if (int.class.equals(param[j]))  
  27.   cost += 3;  
  28. else if (long.class.equals(param[j]))  
  29.   cost += 4;  
  30. else if (param[j].isPrimitive())  
  31.   cost += 5;  
  32. else  
  33.   cost += 6;  
  34.      }  
  35.   
  36.      if (cost < 0 || cost > (1 << 48))  
  37. cost = 1 << 48;  
  38.   
  39.      cost += (long) param.length << 48;  
  40.      // _constructor will reference to the constructor with least parameters.  
  41.      if (cost < bestCost) {  
  42.        _constructor = constructors[i];  
  43.        bestCost = cost;  
  44.      }  
  45.    }  
  46.   
  47.    if (_constructor != null) {  
  48.      _constructor.setAccessible(true);  
  49.      Class []params = _constructor.getParameterTypes();  
  50.      _constructorArgs = new Object[params.length];  
  51.      for (int i = 0; i < params.length; i++) {  
  52.        _constructorArgs[i] = getParamArg(params[i]);  
  53.      }  
  54.    }  
  55.  }  

從JavaDeserializer的構造方法中可以看出，這里_constructor會被賦予參數最少的那個構造器。再回過頭去看看CountObject的構造器（就上面列出來的那一個），不難看出，這里的_constructor就是上面的那個構造器了。

Java代碼  收藏代碼
  1. /** 
  2.  * Creates a map of the classes fields. 
  3.  */  
  4. protected static Object getParamArg(Class cl)  
  5. {  
  6.   if (! cl.isPrimitive())  
  7.     return null;  
  8.   else if (boolean.class.equals(cl))  
  9.     return Boolean.FALSE;  
  10.   else if (byte.class.equals(cl))  
  11.     return new Byte((byte) 0);  
  12.   else if (short.class.equals(cl))  
  13.     return new Short((short) 0);  
  14.   else if (char.class.equals(cl))  
  15.     return new Character((char) 0);  
  16.   else if (int.class.equals(cl))  
  17.     return Integer.valueOf(0);  
  18.   else if (long.class.equals(cl))  
  19.     return Long.valueOf(0);  
  20.   else if (float.class.equals(cl))  
  21.     return Float.valueOf(0);  
  22.   else if (double.class.equals(cl))  
  23.     return Double.valueOf(0);  
  24.   else  
  25.     throw new UnsupportedOperationException();  
  26. }  

參看上面的getParamArg方法，就可以知道，由于CountObject唯一的一個構造器的兩個參數都不是基本類型，所以這里_constructorArgs所包含的值全部是null。

OK，到這里，上面的異常就搞清楚了，Hessian反序列化時，使用反射調用構造函數生成對象時，傳入的參數不合法，造成了上面的異常。知道了原因，解決的方法也很簡單，就是添加了一個無參的構造器給CountObject，于是上面的問題就解決了。。。

這里，需要注意的是，如果序列化機制使用的是Hessian，序列化的對象又沒有提供默認的無參構造器時，需要注意上面類似的問題了。

Java本身反序列化問題

Java本身的反序列化機制雖然性能稍差一些，但本身使用的約束條件相對卻要寬松一些，其實只要滿足下面兩條，一個類對象就是可以完美支持序列化機制了：


  1. 類實現java.io.Serializable接口。
  2. 類包含的所有屬性都是實現了java.io.Serializable接口的，或者被標記為了transient。

對于構造函數本身沒有任何約束。這里，Java序列化本身其實也是和new以及Java反射機制“平級”的實例化對象的方式。所以，對于單例模式的場景，還是需要考慮是否會有序列化因素造成的單例失效（因為他實例化對象不依賴于構造器，所以一個private的構造器顯然沒法阻止他的“胡作非為”）。當然，對于這種情況，也可以自己實現下面的方法：

 

Java代碼  收藏代碼
  1. private Object readResolve()  

通過實現上面的方法，自己可以在其中明確指定，放回的對象的實例是哪一個。但對于通過如上方式保證的單例模式至少需要注意一下兩點：


  1. readResolve方法的可見性（public/protected/private）問題：因為如果這個方法不是private的，就有可能被起子類直接繼承過去。這可能造成你在反序列化子類對象時出錯（因為這個方法返回了父類的某個固定的對象）。
  2. 使用readResolve方法時，往往比較容易返回某個固定的對象。但這其實和真正的對象反序列化其實是有點矛盾的。因為你反序列化對象時，多數場景都是希望恢復原來的對象的“狀態”，而不是固定的某個對象。所以只要你的類內的屬性有沒有被標識成transient的，就要格外小心了。

鑒于上面所說的稍微復雜的現象，如果單純的考慮單例的需要，更好的方式是通過枚舉來實現，因為枚舉至少可以在JVM層面，幫你保證每個枚舉實例一定是單例的，即使使用反序列化機制，也無法繞過這個限制，所以可以幫你省不少心。

好了，上面扯的有點遠了，關于Java本身的序列化機制，下面寫了一個簡單的把對象序列化成字節數組，再由字節數組反序列化回來的例子，看完之后應該會更明了一些：

 

Java代碼  收藏代碼
  1. public class Person implements Serializable {  
  2.   
  3.     String name;  
  4.     int age;  
  5.   
  6.     public Person(String name, int age) {  
  7.         this.name = name;  
  8.         this.age = age;  
  9.     }  
  10.   
  11.     @Override  
  12.     public String toString() {  
  13.         return "Person{" +  
  14.             "name='" + name + '\'' +  
  15.             ", age=" + age +  
  16.             '}';  
  17.     }  
  18.   
  19.     private static class Employee extends Person{  
  20.   
  21.         String title;  
  22.   
  23.         private Employee(String name, int age, String title) {  
  24.             super(name, age);  
  25.             this.title = title;  
  26.         }  
  27.   
  28.         @Override  
  29.         public String toString() {  
  30.             return "Employee{" + "name='" + name + '\'' +  
  31.                 ", age=" + age + '\'' +  
  32.                 ", title='" + title + '\'' +  
  33.                 '}';  
  34.         }  
  35.     }  
  36.   
  37.     public static void main(String[] args) {  
  38.         byte[] bytes;  
  39.         Person person1 = new Person( "test1",20 );  
  40.         Person person2;  
  41.         Employee employee1 = new Employee( "employee1",25,"Manager" );  
  42.         Employee employee2;  
  43.   
  44.         ByteArrayOutputStream byteOutputStream = null;  
  45.         ObjectOutputStream objectOutputStream = null;  
  46.   
  47.         ByteArrayInputStream byteArrayInputStream = null;  
  48.         ObjectInputStream objectInputStream = null;  
  49.   
  50.         try {  
  51.             //generate byteArray.  
  52.             byteOutputStream = new ByteArrayOutputStream( );  
  53.             objectOutputStream = new ObjectOutputStream( byteOutputStream);  
  54.             //serialize person1  
  55.             objectOutputStream.writeObject( person1 );  
  56.             //serialize employee1  
  57.             objectOutputStream.writeObject( employee1 );  
  58.   
  59.             bytes = byteOutputStream.toByteArray();  
  60.   
  61.             for (byte aByte : bytes) {  
  62.                 System.out.print(aByte);  
  63.             }  
  64.             System.out.println();  
  65.             System.out.println("Bytes's length is :"+bytes.length);  
  66.   
  67.             //generate Object from byteArray.  
  68.             byteArrayInputStream = new ByteArrayInputStream( bytes );  
  69.             objectInputStream = new ObjectInputStream( byteArrayInputStream );  
  70.             //deserialize person1  
  71.             person2 = (Person)objectInputStream.readObject();  
  72.             //deserialize employee1  
  73.             employee2 = (Employee)objectInputStream.readObject();  
  74.             System.out.println("person2 got from byteArray is : "+person2);  
  75.             System.out.println("employee2 got from byteArray is : "+employee2);  
  76.   
  77.             System.out.println("person1's memory id :"+Integer.toHexString(person1.hashCode()));  
  78.             System.out.println("person2's memory id :"+Integer.toHexString(person2.hashCode()));  
  79.             System.out.println("employee1's memory id :"+Integer.toHexString(employee1.hashCode()));  
  80.             System.out.println("employee2's memory id :"+Integer.toHexString(employee2.hashCode()));  
  81.   
  82.         } catch (IOException e) {  
  83.             e.printStackTrace();  
  84.         }catch ( ClassNotFoundException ce ){  
  85.             ce.printStackTrace();  
  86.         }  
  87.         finally {  
  88.             try {  
  89.                 byteOutputStream.close();  
  90.                 objectOutputStream.close();  
  91.                 byteArrayInputStream.close();  
  92.                 objectInputStream.close();  
  93.             } catch (IOException e) {  
  94.                 e.printStackTrace();  
  95.             }  
  96.         }  
  97.     }  
  98. }  

上面代碼執行的結果如下：

Java代碼  收藏代碼
  1. -84-19051151140329911110946115107121461191191194611510111410597108105122971161051111104680101114115111110-97-123-26-11-111120-40-115202730397103101760411097109101116018761069711897471089711010347831161141051101035912011200020116051161011151164911511404199111109461151071214611911911946115101114105971081051229711610511111046801011141151111103669109112108111121101101-11-66110-28-62-10611536201760511610511610810111301260112011301260000025116091011091121081111211011014911607779711097103101114  
  2. Bytes's length is :200  
  3. person2 got from byteArray is : Person{name='test1', age=20}  
  4. employee2 got from byteArray is : Employee{name='employee1', age=25', title='Manager'}  
  5. person1's memory id :29173ef  
  6. person2's memory id :96fa474  
  7. employee1's memory id :6c121f1d  
  8. employee2's memory id :95c083  

最后再補充一個Java序列化規范的地址，有時間時再細讀一下：http://docs.oracle.com/javase/7/docs/platform/serialization/spec/serial-arch.html