注意hessian的序列化问题

 最近在项目中发现一个很奇怪的问题，将ProductDraftDO对象传输到远程服务上，远程服务获取的ProductDraftDO对象的ActionTrace为null。而在传输之前明明是有值的。ActionTrace类已经实现了序列化接口，它的所有属性都是可序列化的。

最后查明了原因，是序列化的问题。由于项目中的远程服务用dubbo实现，Hessian是dubbo的默认序列化协议，它比java的序列化性能要高很多。当hessian序列化一个对象时，默认的序列化类是com.caucho.hessian.io. JavaSerializer。

JavaSerializer的writeObject方法代码片段如下：

    try {

      out.writeMapBegin(cl.getName());

      for (int i = 0; i < _fields.length; i++) {

           Field field = _fields[i];

           out.writeString(field.getName());

           out.writeObject(field.get(obj));

      }

      out.writeMapEnd();

    } catch (IllegalAccessException e) {

      throw new IOException(String.valueOf(e));

}

将属性和属性值都写入到流中，这里看起来似乎没有什么问题，可是这些Field是怎么来的呢？看看JavaSerializer的构造函数：

  

public JavaSerializer(Class cl) {

        _writeReplace = getWriteReplace(cl);

        if (_writeReplace != null) _writeReplace.setAccessible(true);

 

        ArrayList primitiveFields = new ArrayList();

        ArrayList compoundFields = new ArrayList();

        for (; cl != null; cl = cl.getSuperclass()) {

            Field[] fields = cl.getDeclaredFields();

            for (int i = 0; i < fields.length; i++) {

                Field field = fields[i];

                if (Modifier.isTransient(field.getModifiers()) || Modifier.isStatic(field.getModifiers())) continue;

 

                // XXX: could parameterize the handler to only deal with public

                field.setAccessible(true);

 

                if (field.getType().isPrimitive() || field.getType().getName().startsWith("java.lang.")

                    && !field.getType().equals(Object.class)) primitiveFields.add(field);

                else compoundFields.add(field);

            }

        }

 

        ArrayList fields = new ArrayList();

        fields.addAll(primitiveFields);

        fields.addAll(compoundFields);

 

        _fields = new Field[fields.size()];

        fields.toArray(_fields);

    }

获取当前class的所有字段，接着获取父类的所有字段。序列化的时候，所有字段都放在一个ArrayList里，然后依次写入到二进制流中，反序列化的时候，所有字段放在了一个HashMap里，HashMap的key不能重复，悲剧就出现了，如果子类和父类有同名的字段就会有问题，父类的值会把子类的值覆盖掉。

 

看看反序列化时，JavaDeserializer的getFieldMap方法，父类字段会把子类字段覆盖掉。

/**

   * Creates a map of the classes fields.

   */

  protected HashMap getFieldMap(Class cl)

  {

    HashMap fieldMap = new HashMap();

   

    for (; cl != null; cl = cl.getSuperclass()) {

      Field []fields = cl.getDeclaredFields();

      for (int i = 0; i < fields.length; i++) {

        Field field = fields[i];

 

        if (Modifier.isTransient(field.getModifiers()) ||

            Modifier.isStatic(field.getModifiers()))

          continue;

        else if (fieldMap.get(field.getName()) != null)

          continue;

 

        // XXX: could parameterize the handler to only deal with public

        try {

          field.setAccessible(true);

        } catch (Throwable e) {

          e.printStackTrace();

        }

 

        fieldMap.put(field.getName(), field);

      }

    }

 

    return fieldMap;

  }

 

然后根据字段接收值，看看JavaDeserializer的readMap方法的代码片段

      while (!in.isEnd()) {

            Object key = in.readObject();

            Field field = (Field) _fieldMap.get(key);

            if (field != null) {

                Object value = in.readObject(field.getType());

                try {

                    field.set(obj, value);

                } catch (Throwable e) {

                    IOException e1 = new IOException("Failed setting: " + field + " with " + value + "\n"

                                                     + e.toString());

                    e1.initCause(e);

                    throw e1;

                }

            } else {

                Object value = in.readObject();

            }

        }

发送二进制数据时，子类数据在前，父类数据在后。

接收二进制数据时，子类数据在前，父类数据在后。

所以对于同名字段，子类的该字段值会被赋值两次，总是被父类的值覆盖，导致子类的字段值丢失。分析完了，再回过头来看看，ProductDraftDO有一个ActionTrace类型字段actionTrace,父类ProductDO也有一个ActionTrace类型字段actionTrace。由于反序列化时，ProductDraftDO的actionTrace一直被ProductDO的actionTrace覆盖，所以ProductDraftDO的actionTrace总是空的。至于为什么父类和子类都有一个ActionTrace，这是历史原因，这里不讨论。这个问题最初由海滔发现，我对代码做了一个完整的分析。

 

所以，使用hessian序列化时，一定要注意子类和父类不能有同名字段。在使用dubbo时如果没有指定序列化协议，则也要注意这个问题。

 

 

http://blog.163.com/jekyll_zhou@126/blog/static/182047382012103033035925/