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

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

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

采用的是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结果也是这样：

本例中：是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版本略低的问题。

      以上是个人的分析，如有错误，还请大家多多指正。