Hessian序列化的一个潜在问题

一. 最近的用rpc框架的时候，当用hessian序列化对象是一个对象继承另外一个对象的时候，当一个属性在子类和有一个相同属性的时候，反序列化后子类属性总是为null。

二. 示例代码：

DTO对象

public class User implements Serializable {
    private String username ;
    private String password;
    private Integer age;
}

public class UserInfo extends User {
    private String username;
}

序列化代码

      UserInfo user = new UserInfo();
        user.setUsername("hello world");
        user.setPassword("buzhidao");
        user.setAge(21);

        ByteArrayOutputStream os = new ByteArrayOutputStream();
        //Hessian的序列化输出
        HessianOutput ho = new HessianOutput(os);
        ho.writeObject(user);

        byte[] userByte = os.toByteArray();
        ByteArrayInputStream is = new ByteArrayInputStream(userByte);


        //Hessian的反序列化读取对象
        HessianInput hi = new HessianInput(is);
        UserInfo u = (UserInfo) hi.readObject();
        System.out.println("姓名：" + u.getUsername());
        System.out.println("年龄：" + u.getAge());

输出结果：

　　　　姓名：null 

　　　　年龄：21

 三.  一看这个结果一开始的反应就是不应该啊，后来自己带着好奇查看了网上资料终于找到了原因。

       1. hessian序列化的时候会取出对象的所有自定义属性，相同类型的属性是子类在前父类在后的顺序。

       2. hessian在反序列化的时候，是将对象所有属性取出来，存放在一个map中   key = 属性名  value是反序列类，相同名字的会以子类为准进行反序列化。

       3. 相同名字的属性 在反序列化的是时候，由于子类在父类前面，子类的属性总是会被父类的覆盖，由于java多态属性，在上述例子中父类 User.username = null

 四、 下面是关键源码分析 ，hessian版本是4.0.7

     1.序列化

     当序列化对象是一个java自定对象时，默认的序列化类是 UnsafeSerializer

     调用writeObject

 public void writeObject(Object obj, AbstractHessianOutput out)
    throws IOException
  {
    if (out.addRef(obj)) {
      return;
    }
    
    Class<?> cl = obj.getClass();

    int ref = out.writeObjectBegin(cl.getName());

    if (ref >= 0) {
      writeInstance(obj, out);
    }
    else if (ref == -1) {
      writeDefinition20(out);
      out.writeObjectBegin(cl.getName());
      writeInstance(obj, out);
    }
    else {
      writeObject10(obj, out);
    }
  }

 以上代码会调用 writeObject10(obj, out);

 protected void writeObject10(Object obj, AbstractHessianOutput out)
    throws IOException
  {
    for (int i = 0; i < _fields.length; i++) {
      Field field = _fields[i];

      out.writeString(field.getName());

      _fieldSerializers[i].serialize(out, obj);
    }

    out.writeMapEnd();
  }

 

2.反序列化的时候

当反序列化时，默认的反序列化类是 UnsafeSerializer

 会首先根据反序列化类型，创建一个map 

　

  protected HashMap<String,FieldDeserializer> getFieldMap(Class<?> cl)
  {
    HashMap<String,FieldDeserializer> fieldMap
      = new HashMap<String,FieldDeserializer>();

    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();
        }

        Class<?> type = field.getType();
        FieldDeserializer deser;

        if (String.class.equals(type)) {
          deser = new StringFieldDeserializer(field);
        }
        else if (byte.class.equals(type)) {
          deser = new ByteFieldDeserializer(field);
        }
        。。。。。。
   

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

    return fieldMap;
  }

 如果是String类型的属性，使用的是StringFieldDeserializer   

  StringFieldDeserializer(Field field)
    {
      _field = field;
      _offset = _unsafe.objectFieldOffset(_field);  //这个会把属性对象对象的偏移量设置好
    }

接下来会对每个属性用map对应序列化方式进行反序列化和赋值

  public Object readMap(AbstractHessianInput in, Object obj)
    throws IOException
  {
    try {
      int ref = in.addRef(obj);

      while (! in.isEnd()) {
        Object key = in.readObject();

        FieldDeserializer deser = (FieldDeserializer) _fieldMap.get(key);

        if (deser != null)
          deser.deserialize(in, obj);
        else
          in.readObject();
      }

      in.readMapEnd();

      Object resolve = resolve(in, obj);

      if (obj != resolve)
        in.setRef(ref, resolve);

      return resolve;
    } catch (IOException e) {
      throw e;
    } catch (Exception e) {
      throw new IOExceptionWrapper(e);
    }
  }

这个是StringFieldDeserializer 反序列化，由于名字相同的属性，反序列化是第一个子类，往后父类的发现map中有就会忽略，所以在属性序列化的时候，先序列化子类的，接着是父类的，但是他们在对象中的偏移量是一样的（用的是同一个反序列化类），所以相同名字的属相，子类总是会被父类覆盖掉。

    @SuppressWarnings("restriction")
    void deserialize(AbstractHessianInput in, Object obj)
      throws IOException
    {
      String value = null;
      
      try {
        value = in.readString();

        _unsafe.putObject(obj, _offset, value);
      } catch (Exception e) {
        logDeserializeError(_field, obj, value, e);
      }
    }

五. 总结

    使用hessian序列化时，一定要注意子类和父类不能有同名字段