dubbo缺省协议父类和子类拥有相同属性导致的反序列化为null问题排查

灰太狼 2021-09-30 04:08 166阅读 0赞

** 注意：文中涉及的的dubbo版本为公司内部定制化版本。**

今天在工作中遇到一个问题：由于自己的疏忽，定义dubbo接口入参时，**WareQueryPageDTO**继承了一个父类**BizCodeBaseDTO**，但是有个属性**String bizCode**，父类和子类中都存在。本地单元测试，接口都能根据bizCode值查询出对应的数据，但是dubbo Consumer端查出的数据一直是错误的。

检查日志发现，接口消费端明明传入了bizCode值，但是却没有解析出来：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMDc2MzQ1_size_16_color_FFFFFF_t_70][]采用的是dubbo缺省协议，序列化方式是Hessian 二进制序列化，在反序列化时会出现父类的同名属性覆盖子类的同名属性问题，所以就变成null，解析不到了。我们使用的是dubbo 2.8.4版本【公司内部定制版本】，这里序列化和反序列化涉及到两个类，在dubbo-serialization-api 包中：

序列化类：com.alibaba.com.caucho.hessian.io.JavaSerializer

反序列化类：com.alibaba.com.caucho.hessian.io.JavaDeserializer

先看一下JavaSerializer序列化方式：

public JavaSerializer(Class cl, ClassLoader loader) {
            this.introspectWriteReplace(cl, loader);
            if (this._writeReplace != null) {
                this._writeReplace.setAccessible(true);
            }
    
            List primitiveFields = new ArrayList();
    
            ArrayList compoundFields;
            int i;
            for(compoundFields = new ArrayList(); cl != null; cl = cl.getSuperclass()) {
                Field[] fields = cl.getDeclaredFields();
    
                for(i = 0; i < fields.length; ++i) {
                    Field field = fields[i];
                    if (!Modifier.isTransient(field.getModifiers()) && !Modifier.isStatic(field.getModifiers())) {
                        field.setAccessible(true);
                        if (!field.getType().isPrimitive() && (!field.getType().getName().startsWith("java.lang.") || field.getType().equals(Object.class))) {
                            compoundFields.add(field);
                        } else {
                            primitiveFields.add(field);
                        }
                    }
                }
            }
    
            List fields = new ArrayList();
            fields.addAll(primitiveFields);
            fields.addAll(compoundFields);
            Collections.reverse(fields);
            this._fields = new Field[fields.size()];
            fields.toArray(this._fields);
            this._fieldSerializers = new JavaSerializer.FieldSerializer[this._fields.length];
    
            for(i = 0; i < this._fields.length; ++i) {
                this._fieldSerializers[i] = getFieldSerializer(this._fields[i].getType());
            }
    
        }

在循环中先存储子类的属性（基本属性primitiveFields + 引用属性compoundFields），后存储父类的属性，但是

Collections.reverse(fields);

这行代码在一些低版本中是不存在的，通过逆序操作，其实父类的属性在前面，子类属性在后面了。我本地debug结果也是这样：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMDc2MzQ1_size_16_color_FFFFFF_t_70 1][]

本例中：是WaresQueryPageDTO extends BizCodeBaseDTO，相同的属性是String bizCode。

再看一下JavaDeserializer反序列化方式：

//组装HashMap
     protected HashMap getFieldMap(Class cl) {
            HashMap fieldMap;
            for(fieldMap = new HashMap(); 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()) && fieldMap.get(field.getName()) == null) {
                        try {
                            field.setAccessible(true);
                        } catch (Throwable var8) {
                            var8.printStackTrace();
                        }
    
                        Class type = field.getType();
                        Object deser;
                        if (String.class.equals(type)) {
                            deser = new JavaDeserializer.StringFieldDeserializer(field);
                        } else if (Byte.TYPE.equals(type)) {
                            deser = new JavaDeserializer.ByteFieldDeserializer(field);
                        } else if (Short.TYPE.equals(type)) {
                            deser = new JavaDeserializer.ShortFieldDeserializer(field);
                        } else if (Integer.TYPE.equals(type)) {
                            deser = new JavaDeserializer.IntFieldDeserializer(field);
                        } else if (Long.TYPE.equals(type)) {
                            deser = new JavaDeserializer.LongFieldDeserializer(field);
                        } else if (Float.TYPE.equals(type)) {
                            deser = new JavaDeserializer.FloatFieldDeserializer(field);
                        } else if (Double.TYPE.equals(type)) {
                            deser = new JavaDeserializer.DoubleFieldDeserializer(field);
                        } else if (Boolean.TYPE.equals(type)) {
                            deser = new JavaDeserializer.BooleanFieldDeserializer(field);
                        } else if (Date.class.equals(type)) {
                            deser = new JavaDeserializer.SqlDateFieldDeserializer(field);
                        } else if (Timestamp.class.equals(type)) {
                            deser = new JavaDeserializer.SqlTimestampFieldDeserializer(field);
                        } else if (Time.class.equals(type)) {
                            deser = new JavaDeserializer.SqlTimeFieldDeserializer(field);
                        } else if (Map.class.equals(type) && field.getGenericType() != field.getType()) {
                            deser = new JavaDeserializer.ObjectMapFieldDeserializer(field);
                        } else if (List.class.equals(type) && field.getGenericType() != field.getType()) {
                            deser = new JavaDeserializer.ObjectListFieldDeserializer(field);
                        } else {
                            deser = new JavaDeserializer.ObjectFieldDeserializer(field);
                        }
    
                        fieldMap.put(field.getName(), deser);
                    }
                }
            }
    
            return fieldMap;
        }
    
    //反序列化
     public Object readMap(AbstractHessianInput in, Object obj) throws IOException {
            try {
                int ref = in.addRef(obj);
    
                Object resolve;
                while(!in.isEnd()) {
                    resolve = in.readObject();
                    JavaDeserializer.FieldDeserializer deser = (JavaDeserializer.FieldDeserializer)this._fieldMap.get(resolve);
                    if (deser != null) {
                        deser.deserialize(in, obj);
                    } else {
                        in.readObject();
                    }
                }
    
                in.readMapEnd();
                resolve = this.resolve(obj);
                if (obj != resolve) {
                    in.setRef(ref, resolve);
                }
    
                return resolve;
            } catch (IOException var6) {
                throw var6;
            } catch (Exception var7) {
                throw new IOExceptionWrapper(var7);
            }
        }

是把序列化中的属性List放到HashMap中，HashMap的key用的是字符串类型：field.getName()。如果是低版本的Dubbo框架，没有上面Collections.reverse(fields);这行代码，的确会导致解析失败，因为HashMap的key是唯一的，如果没有这行代码，属性List是子类的在前，父类的在后，这样反序列化时，如例中的bizCode，子类的属性有值，HashMap赋值了，但是后面父类中的bizCode没有值，所以又被赋为null了。

到这里，我为什么会遇到父类子类bizCode反序列化为null的情况呢？我怀疑是对方Consumer端dubbo服务版本较低，是有问题的版本，可能没有逆序父类子类顺序那行代码导致的。我本地启动一个Provider服务和Consumer服务，发现调用是没有问题的，数据返回正常。翌日，询问了一下接口调用方，反馈他们使用的dubbo版本是2.6.8版本，查了一下2.6.8版本的JavaSerializer序列化方式那一段代码：

public JavaSerializer(Class cl, ClassLoader loader) {
            this.introspectWriteReplace(cl, loader);
            if (this._writeReplace != null) {
                this._writeReplace.setAccessible(true);
            }
    
            ArrayList primitiveFields = new ArrayList();
    
            ArrayList compoundFields;
            int i;
            for(compoundFields = new ArrayList(); cl != null; cl = cl.getSuperclass()) {
                Field[] fields = cl.getDeclaredFields();
    
                for(i = 0; i < fields.length; ++i) {
                    Field field = fields[i];
                    if (!Modifier.isTransient(field.getModifiers()) && !Modifier.isStatic(field.getModifiers())) {
                        field.setAccessible(true);
                        if (!field.getType().isPrimitive() && (!field.getType().getName().startsWith("java.lang.") || field.getType().equals(Object.class))) {
                            compoundFields.add(field);
                        } else {
                            primitiveFields.add(field);
                        }
                    }
                }
            }
            /**注意：没有属性逆转那行代码*/
            ArrayList fields = new ArrayList();
            fields.addAll(primitiveFields);
            fields.addAll(compoundFields);
            this._fields = new Field[fields.size()];
            fields.toArray(this._fields);
            this._fieldSerializers = new JavaSerializer.FieldSerializer[this._fields.length];
    
            for(i = 0; i < this._fields.length; ++i) {
                this._fieldSerializers[i] = getFieldSerializer(this._fields[i].getType());
            }
    
        }

可以看出，在2.6.8版本里，是没有属性逆转那行代码的，这会导致子类属性在前，父类属性在后，反序列化时子类的属性值就被父类的相同属性覆盖了，这也解释了为什么我本地启动两个服务调用没问题，第三方调用有问题，因为是第三方dubbo版本略低的问题。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMDc2MzQ1_size_16_color_FFFFFF_t_70]: /images/20210920/2f950f32c9f143e1ad40c6d6fccd37c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMDc2MzQ1_size_16_color_FFFFFF_t_70 1]: /images/20210920/f2072a2a2c0342419cd8457532b06b79.png