首页 > 其他 > 详细

Hessian序列化的一个潜在问题

时间:2017-07-17 23:44:03      阅读:67      评论:0      收藏:0      [点我收藏+]

标签:源码   owa   nds   begin   属性   ack   tty   throw   有一个   

一. 最近的用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序列化时,一定要注意子类和父类不能有同名字段

 

Hessian序列化的一个潜在问题

标签:源码   owa   nds   begin   属性   ack   tty   throw   有一个   

原文:http://www.cnblogs.com/yfyzy/p/7197679.html

(0)
(0)
   
举报
评论 一句话评论(0
0条  
登录后才能评论!
© 2014 bubuko.com 版权所有 鲁ICP备09046678号-4
打开技术之扣,分享程序人生!
             

鲁公网安备 37021202000002号