Dubbo序列化之hessian2

最新推荐文章于 2024-06-07 16:18:42 发布
最新推荐文章于 2024-06-07 16:18:42 发布
阅读量866 收藏
点赞数
文章标签： java json 数据库
原文链接：https://juejin.im/post/5a4ef32d6fb9a01c982c5f6d
版权

title: Dubbo序列化之hessian2 tags:

  • dubbo
  • hessian2
  • 序列化
  • 丢失字段 categories: dubbo date: 2017-06-25 18:18:54

根据前面的说明可以知道序列化功能依然使用spi，我们来查看一下

    package com.alibaba.dubbo.common.serialize;
     
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
     
    import com.alibaba.dubbo.common.URL;
    import com.alibaba.dubbo.common.extension.Adaptive;
    import com.alibaba.dubbo.common.extension.SPI;
     
    /**
     * Serialization. (SPI, Singleton, ThreadSafe)
     *
     * @author ding.lid
     * @author william.liangf
     */
    @SPI("hessian2")
    public interface Serialization {
     
        /**
         * get content type id
         *
         * @return content type id
         */
        byte getContentTypeId();
     
        /**
         * get content type
         *
         * @return content type
         */
        String getContentType();
     
        /**
         * create serializer
         * @param url
         * @param output
         * @return serializer
         * @throws IOException
         */
        @Adaptive
        ObjectOutput serialize(URL url, OutputStream output) throws IOException;
     
        /**
         * create deserializer
         * @param url
         * @param input
         * @return deserializer
         * @throws IOException
         */
        @Adaptive
        ObjectInput deserialize(URL url, InputStream input) throws IOException;
     
    }
复制代码

很明显 默认情况我们使用hession2来作为序列化

    dubbo=com.alibaba.dubbo.common.serialize.support.dubbo.DubboSerialization
    hessian2=com.alibaba.dubbo.common.serialize.support.hessian.Hessian2Serialization
    java=com.alibaba.dubbo.common.serialize.support.java.JavaSerialization
    compactedjava=com.alibaba.dubbo.common.serialize.support.java.CompactedJavaSerialization
    json=com.alibaba.dubbo.common.serialize.support.json.JsonSerialization
    fastjson=com.alibaba.dubbo.common.serialize.support.json.FastJsonSerialization
    nativejava=com.alibaba.dubbo.common.serialize.support.nativejava.NativeJavaSerialization
复制代码

关于hession是caucho提供的协议，知名服务器resin也是他家的产品

据dubbo官方研究表名hession2在系统中推荐生产使用。但是我们发现在序列化过程中出现了丢字段的情况。

下面分析一下序列化

首先从正向序列化来看：

    Serializer serializer;
     
        serializer = (Serializer) _staticSerializerMap.get(cl);
        if (serializer != null)
          return serializer;
     
        if (_cachedSerializerMap != null) {
          synchronized (_cachedSerializerMap) {
       serializer = (Serializer) _cachedSerializerMap.get(cl);
          }
           
          if (serializer != null)
       return serializer;
        }
     
        for (int i = 0;
        serializer == null && _factories != null && i < _factories.size();
        i++) {
          AbstractSerializerFactory factory;
     
          factory = (AbstractSerializerFactory) _factories.get(i);
     
          serializer = factory.getSerializer(cl);
        }
     
        if (serializer != null) {
        }
     
        else if (JavaSerializer.getWriteReplace(cl) != null)
          serializer = new JavaSerializer(cl, _loader);
     
        else if (HessianRemoteObject.class.isAssignableFrom(cl))
          serializer = new RemoteSerializer();
     
    //    else if (BurlapRemoteObject.class.isAssignableFrom(cl))
    //      serializer = new RemoteSerializer();
     
        else if (Map.class.isAssignableFrom(cl)) {
          if (_mapSerializer == null)
       _mapSerializer = new MapSerializer();
           
          serializer = _mapSerializer;
        }
        else if (Collection.class.isAssignableFrom(cl)) {
          if (_collectionSerializer == null) {
       _collectionSerializer = new CollectionSerializer();
          }
     
          serializer = _collectionSerializer;
        }
     
        else if (cl.isArray())
          serializer = new ArraySerializer();
     
        else if (Throwable.class.isAssignableFrom(cl))
          serializer = new ThrowableSerializer(cl, getClassLoader());
     
        else if (InputStream.class.isAssignableFrom(cl))
          serializer = new InputStreamSerializer();
     
        else if (Iterator.class.isAssignableFrom(cl))
          serializer = IteratorSerializer.create();
     
        else if (Enumeration.class.isAssignableFrom(cl))
          serializer = EnumerationSerializer.create();
         
        else if (Calendar.class.isAssignableFrom(cl))
          serializer = CalendarSerializer.create();
         
        else if (Locale.class.isAssignableFrom(cl))
          serializer = LocaleSerializer.create();
         
        else if (Enum.class.isAssignableFrom(cl))
          serializer = new EnumSerializer(cl);
     
        if (serializer == null)
          serializer = getDefaultSerializer(cl);
     
        if (_cachedSerializerMap == null)
          _cachedSerializerMap = new HashMap(8);
     
        synchronized (_cachedSerializerMap) {
          _cachedSerializerMap.put(cl, serializer);
        }
     
        return serializer;
      }
复制代码

很明显当正常的javabean过来将会获得getDefaultSerializer也就是JavaSerializer

    public JavaSerializer(Class cl, ClassLoader loader)
     {
       introspectWriteReplace(cl, loader);
        
       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);
     
       _fieldSerializers = new FieldSerializer[_fields.length];
     
       for (int i = 0; i < _fields.length; i++) {
         _fieldSerializers[i] = getFieldSerializer(_fields[i].getType());
       }
     }
复制代码

  1. 首先查找是否包含writeReplace方法

  2. 将所有的包含超类的字段全部放入arrayList中（去除静态和瞬态），先放入原生类型后放入包装类型

  3. 根据field类型放入对应的序列化器

    以上初始化完成后将javabean的元信息写入流并且进行实例的序列化

分析完序列化步骤我们来看一下反序列化步骤

同样的道理，默认将会返回JavaDeserializer

    public JavaDeserializer(Class cl)
     {
       _type = cl;
       _fieldMap = getFieldMap(cl);
     
       _readResolve = getReadResolve(cl);
     
       if (_readResolve != null) {
         _readResolve.setAccessible(true);
       }
     
       Constructor []constructors = cl.getDeclaredConstructors();
       long bestCost = Long.MAX_VALUE;
     
       for (int i = 0; i < constructors.length; i++) {
         Class []param = constructors[i].getParameterTypes();
         long cost = 0;
     
         for (int j = 0; j < param.length; j++) {
    cost = 4 * cost;
     
    if (Object.class.equals(param[j]))
      cost += 1;
    else if (String.class.equals(param[j]))
      cost += 2;
    else if (int.class.equals(param[j]))
      cost += 3;
    else if (long.class.equals(param[j]))
      cost += 4;
    else if (param[j].isPrimitive())
      cost += 5;
    else
      cost += 6;
         }
     
         if (cost < 0 || cost > (1 << 48))
    cost = 1 << 48;
     
         cost += (long) param.length << 48;
     
         if (cost < bestCost) {
           _constructor = constructors[i];
           bestCost = cost;
         }
       }
     
       if (_constructor != null) {
         _constructor.setAccessible(true);
         Class []params = _constructor.getParameterTypes();
         _constructorArgs = new Object[params.length];
         for (int i = 0; i < params.length; i++) {
           _constructorArgs[i] = getParamArg(params[i]);
         }
       }
     }
复制代码
  1. 获取字段集合
  2. 获取readResolve方法
  3. 获取最佳构造函数

获取字段集合代码如下

    /**
      * 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();
           }
     
    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);
    }
    else if (short.class.equals(type)) {
      deser = new ShortFieldDeserializer(field);
    }
    else if (int.class.equals(type)) {
      deser = new IntFieldDeserializer(field);
    }
    else if (long.class.equals(type)) {
      deser = new LongFieldDeserializer(field);
    }
    else if (float.class.equals(type)) {
      deser = new FloatFieldDeserializer(field);
    }
    else if (double.class.equals(type)) {
      deser = new DoubleFieldDeserializer(field);
    }
    else if (boolean.class.equals(type)) {
      deser = new BooleanFieldDeserializer(field);
    }
    else if (java.sql.Date.class.equals(type)) {
      deser = new SqlDateFieldDeserializer(field);
     }
    else if (java.sql.Timestamp.class.equals(type)) {
      deser = new SqlTimestampFieldDeserializer(field);
     }
    else if (java.sql.Time.class.equals(type)) {
      deser = new SqlTimeFieldDeserializer(field);
     }
    else {
      deser = new ObjectFieldDeserializer(field);
    }
     
           fieldMap.put(field.getName(), deser);
         }
       }
     
       return fieldMap;
     }
复制代码

hashmap很明显如果此处出现了同名覆盖的字段，此处将覆盖

获取构造函数参数方法如下

    /**
     * Creates a map of the classes fields.
     */
    protected static Object getParamArg(Class cl)
    {
      if (! cl.isPrimitive())
        return null;
      else if (boolean.class.equals(cl))
        return Boolean.FALSE;
      else if (byte.class.equals(cl))
        return new Byte((byte) 0);
      else if (short.class.equals(cl))
        return new Short((short) 0);
      else if (char.class.equals(cl))
        return new Character((char) 0);
      else if (int.class.equals(cl))
        return Integer.valueOf(0);
      else if (long.class.equals(cl))
        return Long.valueOf(0);
      else if (float.class.equals(cl))
        return Float.valueOf(0);
      else if (double.class.equals(cl))
        return Double.valueOf(0);
      else
        throw new UnsupportedOperationException();
    }
复制代码

当构造函数为原生类型默认为0或false，否则传入null（构造函数如果是包含参数的请注意，很可能出现问题）

当读取实例时代码如下

    private Object readObjectInstance(Class cl, ObjectDefinition def)
      throws IOException
    {
      String type = def.getType();
      String []fieldNames = def.getFieldNames();
       
      if (cl != null) {
        Deserializer reader;
        reader = findSerializerFactory().getObjectDeserializer(type, cl);
     
        return reader.readObject(this, fieldNames);
      }
      else {
        return findSerializerFactory().readObject(this, type, fieldNames);
      }
    }
复制代码

明显此处fields是从hessionInput中读取（即序列化时的arraylist）

那么如果存在和父类同名的属性时，由于前面的说明会将之类的属性排在前面。那么通常在写到父类的属性通常都会为null（父类的同名字段通常都是没有赋值）

那么在读取的时候自然会将原来的已经设置的值给重新设置为null。

总结hession2存在的两个问题

  1. 构造函数如果包含参数，那么在hession初始化的时候将会给引用类型传入null，其他类型传入0或者false，要保证不要产生空指针
  2. 如果序列化的不是普通类型包含多层级的 父类，要确保子类不要包含父类同名字段，否则很容易出现子类字段在赋值后被重新赋值为空，造成字段丢失

比如如下

    /**
     * Created by Geekkiller on 2017/3/16.
     */
    public class TmRemindSo extends So {
     
        private static final long serialVersionUID = 1L;
        /**
         * 是否分页：
         */
        private boolean isPage = false;
        /**
         * 上次保养起始日
         */
        private String beginMaintainDate;
        /**
         * 上次保养结束日
         */
        private String endMaintainDate;
        /**
         * 下次保养起始日
         */
        private String beginNextMaintainDate;
        /**
         * 下次保养结束日
         */
        private String endNextMaintainDate;
        /**
         * 客户生日起始
         */
        private String beginBirthday;
        /**
         * 客户生日结束
         */
        private String endBirthday;
     
        private String beginLastServiceTime;
     
        private String endLastServiceTime;
     
        private String beginCardEndTime;
        private String endCardEndTime;
        private String cardName;
        private String cardType;
     
        private String beginDriverExpiryDate;
        private String endDriverExpiryDate;
     
        private String beginAnnualDate;
        private String endAnnualDate;
     
        private String idStore; //门店id
     
        private String idOwnOrg;            //组织ID
    }
    /**
     * Created by qixiaobo on 2016/10/11.
     * 数据库查询基类
     */
    public class So implements Serializable, Pagable, Sortable {
     
        private static final long serialVersionUID = 436513842210828356L;
        /*
         * 当前页码
         */
        private int currentPage = 1;
        private int pageSize = AppConstant.MIDPAGESIZE;
        private Integer id;
        private String pkId;
        /**
         * pkId的列表
         */
        private List<String> pkIdList;
        private String idOwnOrg;
        /**
         * 创建人
         */
        private String creator;
        private List<Sort> sorts = new LinkedList<>();
    }
复制代码

如上idownorg字段存在同名，在hessian环境下就会出现字段丢失

weixin_34247032
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
dubbo源码：dubbo hessian2序列化协议
苦行僧
04-22 4433
文章目录1.dubbo hessian2 序列化协议2. dubbo hessian2 序列化协议在dubbo中的应用2.1 调用链路分析2.2 序列化原理分析3. dubbo jdk序列化协议 1.dubbo hessian2 序列化协议 Dubbo 默认的hessian2序列化协议内部嵌入了Hessian-lite源码，其中Hessian-lite最初是阿里巴巴dubbo嵌入官方hessian...
dubbo源码依赖hessian_lite.jar
02-28
dubbo源码依赖hessian_lite，可以使用mvn install命令将jar包安装到本地的maven仓库
对比 JSON 和 Hessian2 的序列化格式
最新发布
Enya61的博客
06-07 712
特性JSONHessian2可读性高，可读性强，便于调试低，二进制格式，不便于调试语言无关性高，几乎所有语言都支持中等，支持多语言但依赖库支持性能低，序列化和反序列化速度较慢高，序列化和反序列化速度非常快数据体积大，包含字段名等额外信息小，二进制格式，数据体积小类型安全低，类型不严格，可能导致解析错误高，包含类型信息，保证数据一致性应用场景Web 开发，API 接口，广泛应用高性能 RPC 调用，高并发场景调试和日志记录容易调试，日志记录友好调试困难，不便于日志记录安全性。
dubbo源码分析-dubbo-serialization
胡矣
08-13 2910
dubbo-serialization dubbo-serialization是dubbo中实现序列化相关的代码。 共5种序列化方式，可从名字直接看出含义，这里不再赘述。 dubbo-serialization-fastjson dubbo-serialization-fst dubbo-serialization-hessian2 dubbo-serialization-jdk ...
Dubbo默认使用什么序列化框架？
CZ-001的博客
09-06 558
Dubbo默认使用的序列化框架是Hessian 2.0。Hessian是一种基于二进制的序列化协议，它具有简单、高效的特点，适用于网络传输和存储数据。Hessian在Dubbo中被广泛使用，因为它可以在不同的编程语言之间进行对象的序列化和反序列化。除了Hessian，Dubbo还支持其他的序列化框架，可以通过配置来选择使用特定的序列化框架。
【Dubbo】默认hession2反序列化机制导致dubbo接口返回HashMap
太空眼睛的专栏
12-20 607
虽然找到了问题的原因，也解决了问题，但依然有疑问，如果启动多次，有时候能正常转成Java对象，是一个随机的状态，感觉启动的时候决定了这个hessian2的类加载器遇到一些莫名其妙的问题时，不要慌，耐心的断点，分析代码查找问题的原因解决问题时，最好深刻理解源码的设计，利用原有框架的扩展性，进行问题的修复，这样的代码是最优雅的。
记一个 dubbo中hessian2反序列化 Map 的一个问题
weixin_33847182的博客
04-15 619
dubbo版本: 2.5.10 解决方案: 改用 "dubbo" 序列化方式 (但是 dubbo 方式也存在一个比较坑的问题 详见: Dubbo序列化多个CopyOnWriteArrayList对象变成同一对象的一个大坑!!) 酌情选择吧, 我也很尴尬 转载于:https://www.cnblogs.com/imyjy/p/10708819.html...
DuBBo(rmi+Hessian).zip
12-16
在Dubbo中，Hessian协议同样可以被用于服务的远程调用，它提供了比RMI更快的序列化和反序列化速度，特别适合于需要高效率通信的场景。 要使用Dubbo与RMI或Hessian集成，我们需要进行以下步骤： 1. **配置服务提供...
Dubbo 序列化协议 5 连问，你接得住不.PDF
03-18
默认就是⾛ dubbo 协议，单⼀⻓连接，进⾏的是 NIO 异步通信，基于 hessian 作为序列化协议。使⽤的场景是：传输数据量⼩ （每次请求在 100kb 以内），但是并发量很⾼。 为了要⽀持⾼并发场景，⼀般是服务提供者就⼏...
dubbo-hessian协议http请求demo（java）
05-08
- 在实际开发中，我们可能会需要编写一些辅助工具类来处理Hessian的相关操作，例如Hessian2Input和Hessian2Output，它们用于读写Hessian序列化的二进制流。 6. **安全性与优化**： - 虽然Hessian协议效率高，但其...
Dubbo序列化协议5连问，你接得住不？.docx
11-03
- **Dubbo协议**：默认协议，采用单个长连接和NIO异步通信，基于Hessian进行序列化。适用于大数据量但并发量高的场景。 - **RMI协议**：基于Java原生序列化，多短连接，适合消费者和提供者数量相近的情况，常用于...
dubbo源码实践-serialize层的例子
Alf的专栏
01-02 617
本文描述了dubbo serialize层API的简单使用。 原理请自行网上搜索（网上描述的都比较详细了，就不在copy一份了。）。
dubbo开启参数校验时-序列化异常
雪落南城的博客
01-10 3692
开启dubbo参数校验时 服务1调用服务2的方法，参数1为@NotNull 调用时未传 但报的异常是序列化问题 异常信息如下： org.apache.dubbo.rpc.RpcException: Failed to invoke the method getLoanInfoByInteractNum in the service net.wecash.capital.plat...
Dubbo之默认协议dubbo
小花生编程
08-24 2486
Dubbo 缺省协议采用单一长连接和 NIO 异步通讯，适合于小数据量大并发的服务调用，以及服务消费者机器数远大于服务提供者机器数的情况。 反之，Dubbo 缺省协议不适合传送大数据量的服务，比如传文件，传视频等，除非请求量很低。 Transporter: mina, netty, grizzy Serialization: dubbo, hessian2, java, json ...
Dubbo Hessian2序列化问题
rhwayfun专栏
12-22 8818
问题定义了一个接口，返回值为Map<String, Byte>，consumer收到结果后，使用Byte value = map.get(key)获取结果，抛出了如下类型转换异常： 如下: java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Byte at sun.reflect.Native
微服务框架（三）Dubbo性能调优配置
若明天不见
07-29 5258
　　此系列文章将会描述Java框架Spring Boot、服务治理框架Dubbo、应用容器引擎Docker，及使用Spring Boot集成Dubbo、Mybatis等开源框架，其中穿插着Spring Boot中日志切面等技术的实现，然后通过gitlab-CI以持续集成为Docker镜像。 　　本文为服务治理框架Dubbo的特性及泛化实现 本系列文章中所使用的框架版本为Spring Bo...
dubbo版本升级关于序列化问题
LALOUY的博客
03-02 5674
最近两年公司项目dubbo进行升级，从2.5.6升级至2.6.9 至今又升级为2.6.10 主要升级的原因是序列化存在漏洞，需要使用hession协议进行序列化操作。 2.6.9 在2.6.9引入白名单，因为hessian默认支持java.*的所有类进行序列化，所以重写AbstractHessian2FactoryInitializer配置白名单参数 是否开启白名单 *static String WHITELIST = "dubbo.application.hessian2.whitelist";*
dubbo配置hessian+dubbo协议共存
热门推荐
ligang5344的专栏
08-02 1万+
根据官方说明：Dubbo缺省协议采用单一长连接和NIO异步通讯，适合于小数据量大并发的服务调用，以及服务消费者机器数远大于服务提供者机器数的情况 Hessian协议用于集成Hessian的服务，Hessian底层采用Http通讯，采用Servlet暴露服务。适用场景：传入传出参数数据包较大，提供者比消费者个数多，提供者压力较大，可传文件。因此比较高效的做法是带上传下载文件的服务使用hessian
dubbo序列化开销
11-29
因此，在Dubbo中，推荐使用Hessian2序列化，它是Dubbo默认使用的序列化方式，也是性能最优的序列化方式之一。 另外，Dubbo为了支持多种序列化算法，单独抽象了一层Serialize层，在整个Dubbo架构中处于最底层，对应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值