关于java:Java-Bean-转-Map-的巨坑注意了

作者：明明如月学长 \
链接：https://juejin.cn/post/711807…

一、背景

有些业务场景下须要将 Java Bean 转成 Map 再应用。

本认为很简略场景，然而坑很多。

二、那些坑

2.0 测试对象

import lombok.Data;

import java.util.Date;

@Data
public class MockObject extends  MockParent{

    private Integer aInteger;

    private Long aLong;

    private Double aDouble;

    private Date aDate;
}

父类

import lombok.Data;

@Data
public class MockParent {private Long parent;}

2.1 JSON 反序列化了类型失落

2.1.1 问题复现

将 Java Bean 转 Map 最常见的伎俩就是应用 JSON 框架，如 fastjson、gson、jackson 等。但应用 JSON 将 Java Bean 转 Map 会导致局部数据类型失落。如应用 fastjson，当属性为 Long 类型但数字小于 Integer 最大值时，反序列成 Map 之后，将变为 Integer 类型。

maven 依赖：

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.8</version>
</dependency>

示例代码：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;

import java.util.Date;
import java.util.Map;

public class JsonDemo {public static void main(String[] args) {MockObject mockObject = new MockObject();
        mockObject.setAInteger(1);
        mockObject.setALong(2L);
        mockObject.setADate(new Date());
        mockObject.setADouble(3.4D);
        mockObject.setParent(3L);

       String json = JSON.toJSONString(mockObject);

        Map<String,Object> map =  JSON.parseObject(json, new TypeReference<Map<String,Object>>(){});

        System.out.println(map);
    }
}

后果打印：

{“parent”:3,”ADouble”:3.4,”ALong”:2,”AInteger”:1,”ADate”:1657299916477}

调试截图：

通过 Java Visualizer 插件进行可视化查看：

2.2.2 问题形容

存在两个问题（1）通过 fastjson 将 Java Bean 转为 Map，类型会产生转变。如 Long 变成 Integer，Date 变成 Long, Double 变成 Decimal 类型等。（2）在某些场景下，Map 的 key 并非和属性名齐全对应，像是通过 get set 办法“推断”进去的属性名。

2.2 BeanMap 转换属性名谬误

2.2.1 commons-beanutils 的 BeanMap

maven 版本：

<!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.9.4</version>
</dependency>

代码示例：

import org.apache.commons.beanutils.BeanMap;
import third.fastjson.MockObject;

import java.util.Date;

public class BeanUtilsDemo {public static void main(String[] args) {MockObject mockObject = new MockObject();
        mockObject.setAInteger(1);
        mockObject.setALong(2L);
        mockObject.setADate(new Date());
        mockObject.setADouble(3.4D);
        mockObject.setParent(3L);

        BeanMap beanMap = new BeanMap(mockObject);
        System.out.println(beanMap);
    }
}

调试截图：

存在和 cglib 一样的问题，尽管类型没问题然而属性名还是不对。

起因剖析：

/**
 * Constructs a new <code>BeanMap</code> that operates on the
 * specified bean.  If the given bean is <code>null</code>, then
 * this map will be empty.
 *
 * @param bean  the bean for this map to operate on
 */
public BeanMap(final Object bean) {
    this.bean = bean;
    initialise();}

要害代码：

private void initialise() {if(getBean() == null) {return;}

    final Class<? extends Object>  beanClass = getBean().getClass();
    try {//BeanInfo beanInfo = Introspector.getBeanInfo( bean, null);
        final BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);
        final PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        if (propertyDescriptors != null) {for (final PropertyDescriptor propertyDescriptor : propertyDescriptors) {if ( propertyDescriptor != null) {final String name = propertyDescriptor.getName();
                    final Method readMethod = propertyDescriptor.getReadMethod();
                    final Method writeMethod = propertyDescriptor.getWriteMethod();
                    final Class<? extends Object> aType = propertyDescriptor.getPropertyType();

                    if (readMethod != null) {readMethods.put( name, readMethod);
                    }
                    if (writeMethod != null) {writeMethods.put( name, writeMethod);
                    }
                    types.put(name, aType);
                }
            }
        }
    }
    catch (final IntrospectionException e) {logWarn(  e);
    }
}

调试一下就会发现，问题出在 BeanInfo 外面 PropertyDescriptor 的 name 不正确。

通过剖析会发现 java.beans.Introspector#getTargetPropertyInfo 办法是字段解析的要害

对于无参的以 get 结尾的办法名从 index =3 处截取，如 getALong 截取后为 ALong，如 getADouble 截取后为 ADouble。

而后去结构 PropertyDescriptor:

/**
 * Creates <code>PropertyDescriptor</code> for the specified bean
 * with the specified name and methods to read/write the property value.
 *
 * @param bean   the type of the target bean
 * @param base   the base name of the property (the rest of the method name)
 * @param read   the method used for reading the property value
 * @param write  the method used for writing the property value
 * @exception IntrospectionException if an exception occurs during introspection
 *
 * @since 1.7
 */
PropertyDescriptor(Class<?> bean, String base, Method read, Method write) throws IntrospectionException {if (bean == null) {throw new IntrospectionException("Target Bean class is null");
    }
    setClass0(bean);
    setName(Introspector.decapitalize(base));
    setReadMethod(read);
    setWriteMethod(write);
    this.baseName = base;
}

底层应用 java.beans.Introspector#decapitalize 进行解析：

/**
 * Utility method to take a string and convert it to normal Java variable
 * name capitalization.  This normally means converting the first
 * character from upper case to lower case, but in the (unusual) special
 * case when there is more than one character and both the first and
 * second characters are upper case, we leave it alone.
 * <p>
 * Thus "FooBah" becomes "fooBah" and "X" becomes "x", but "URL" stays
 * as "URL".
 *
 * @param  name The string to be decapitalized.
 * @return  The decapitalized version of the string.
 */
public static String decapitalize(String name) {if (name == null || name.length() == 0) {return name;}
    if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
                    Character.isUpperCase(name.charAt(0))){return name;}
    char chars[] = name.toCharArray();
    chars[0] = Character.toLowerCase(chars[0]);
    return new String(chars);
}

从代码中咱们能够看出 (1) 当 name 的长度 > 1，且第一个字符和第二个字符都大写时，间接返回参数作为 PropertyDescriptor name。(2) 否则将 name 转为首字母小写

这种解决本意是为了不让属性为相似 URL 这种缩略词转为 uRL，后果“误伤”了咱们这种场景。

2.2.2 应用 cglib 的 BeanMap

cglib 依赖

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib-nodep</artifactId>
        <version>3.2.12</version>
</dependency>

代码示例：

import net.sf.cglib.beans.BeanMap;
import third.fastjson.MockObject;

import java.util.Date;

public class BeanMapDemo {public static void main(String[] args) {MockObject mockObject = new MockObject();
        mockObject.setAInteger(1);
        mockObject.setALong(2L);
        mockObject.setADate(new Date());
        mockObject.setADouble(3.4D);
        mockObject.setParent(3L);

        BeanMap beanMapp = BeanMap.create(mockObject);

        System.out.println(beanMapp);
    }
}

后果展现：咱们发现类型对了，然而属性名仍然不对。

要害代码：net.sf.cglib.core.ReflectUtils#getBeanGetters 底层也会用到 java.beans.Introspector#decapitalize 所以属性名存在一样的问题就难能可贵了。

三、解决办法

3.1 解决方案

解决方案有很多，本文提供一个基于 dubbo 的解决方案。

maven 依赖：

<!-- https://mvnrepository.com/artifact/org.apache.dubbo/dubbo -->
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo</artifactId>
    <version>3.0.9</version>
</dependency>

示例代码：

import org.apache.dubbo.common.utils.PojoUtils;
import third.fastjson.MockObject;

import java.util.Date;

public class DubboPojoDemo {public static void main(String[] args) {MockObject mockObject = new MockObject();
        mockObject.setAInteger(1);
        mockObject.setALong(2L);
        mockObject.setADate(new Date());
        mockObject.setADouble(3.4D);
        mockObject.setParent(3L);

        Object generalize = PojoUtils.generalize(mockObject);

        System.out.println(generalize);
    }
}

调试成果：

Java Visualizer 成果：

3.2 原理解析

外围代码：org.apache.dubbo.common.utils.PojoUtils#generalize(java.lang.Object)

public static Object generalize(Object pojo) {eturn generalize(pojo, new IdentityHashMap());
}

要害代码：

// pojo 待转换的对象
// history 缓存 Map，进步性能
private static Object generalize(Object pojo, Map<Object, Object> history) {if (pojo == null) {return null;}

     // 枚举间接返回枚举名
    if (pojo instanceof Enum<?>) {return ((Enum<?>) pojo).name();}

    // 枚举数组，返回枚举名数组
    if (pojo.getClass().isArray() && Enum.class.isAssignableFrom(pojo.getClass().getComponentType())) {int len = Array.getLength(pojo);
        String[] values = new String[len];
        for (int i = 0; i < len; i++) {values[i] = ((Enum<?>) Array.get(pojo, i)).name();}
        return values;
    }

    // 根本类型返回 pojo 本身
    if (ReflectUtils.isPrimitives(pojo.getClass())) {return pojo;}

    // Class 返回 name
    if (pojo instanceof Class) {return ((Class) pojo).getName();}

    Object o = history.get(pojo);
    if (o != null) {return o;}
    history.put(pojo, pojo);

// 数组类型，递归
    if (pojo.getClass().isArray()) {int len = Array.getLength(pojo);
        Object[] dest = new Object[len];
        history.put(pojo, dest);
        for (int i = 0; i < len; i++) {Object obj = Array.get(pojo, i);
            dest[i] = generalize(obj, history);
        }
        return dest;
    }
// 汇合类型递归
    if (pojo instanceof Collection<?>) {Collection<Object> src = (Collection<Object>) pojo;
        int len = src.size();
        Collection<Object> dest = (pojo instanceof List<?>) ? new ArrayList<Object>(len) : new HashSet<Object>(len);
        history.put(pojo, dest);
        for (Object obj : src) {dest.add(generalize(obj, history));
        }
        return dest;
    }
    // Map 类型，间接 对 key 和 value 解决
    if (pojo instanceof Map<?, ?>) {Map<Object, Object> src = (Map<Object, Object>) pojo;
        Map<Object, Object> dest = createMap(src);
        history.put(pojo, dest);
        for (Map.Entry<Object, Object> obj : src.entrySet()) {dest.put(generalize(obj.getKey(), history), generalize(obj.getValue(), history));
        }
        return dest;
    }
    Map<String, Object> map = new HashMap<String, Object>();
    history.put(pojo, map);

    // 开启生成 class 则写入 pojo 的 class
    if (GENERIC_WITH_CLZ) {map.put("class", pojo.getClass().getName());
    }

  // 解决 get 办法
    for (Method method : pojo.getClass().getMethods()) {if (ReflectUtils.isBeanPropertyReadMethod(method)) {ReflectUtils.makeAccessible(method);
            try {map.put(ReflectUtils.getPropertyNameFromBeanReadMethod(method), generalize(method.invoke(pojo), history));
            } catch (Exception e) {throw new RuntimeException(e.getMessage(), e);
            }
        }
    }
    // 解决私有属性
    for (Field field : pojo.getClass().getFields()) {if (ReflectUtils.isPublicInstanceField(field)) {
            try {Object fieldValue = field.get(pojo);
                // 对象曾经解析过，间接从缓存里读进步性能
                if (history.containsKey(pojo)) {Object pojoGeneralizedValue = history.get(pojo);
                    // 曾经解析过该属性则跳过（如私有属性，且有 get 办法的状况）if (pojoGeneralizedValue instanceof Map
                        && ((Map) pojoGeneralizedValue).containsKey(field.getName())) {continue;}
                }
                if (fieldValue != null) {map.put(field.getName(), generalize(fieldValue, history));
                }
            } catch (Exception e) {throw new RuntimeException(e.getMessage(), e);
            }
        }
    }
    return map;
}

要害截图

org.apache.dubbo.common.utils.ReflectUtils#getPropertyNameFromBeanReadMethod
public static String getPropertyNameFromBeanReadMethod(Method method) {if (isBeanPropertyReadMethod(method)) {
        // get 办法，则从 index =3 的字符小写 + 前面的字符串
        if (method.getName().startsWith("get")) {return method.getName().substring(3, 4).toLowerCase()
                    + method.getName().substring(4);
        }
        // is 结尾办法，index =2 的字符小写 + 前面的字符串
        if (method.getName().startsWith("is")) {return method.getName().substring(2, 3).toLowerCase()
                    + method.getName().substring(3);
        }
    }
    return null;
}

因而，getALong 办法对应的属性名被解析为 aLong。

同时，这么解决也会存在问题。如当属性名叫 URL 时，转为 Map 后 key 就会被解析成 uRL。

从这里看出，当属性名比拟非凡时也很容易出问题，但 dubbo 这个工具类更合乎咱们的预期。更多细节，大家能够依据 DEMO 自行调试学习。

如果想严格和属性保持一致，能够应用反射获取属性名和属性值，加缓存机制晋升解析的效率。

四、总结

Java Bean 转 Map 的坑很多，最常见的就是类型失落和属性名解析谬误的问题。大家在应用 JSON 框架和 Java Bean 转 Map 的框架时要特地小心。平时应用某些框架时，多写一些 DEMO 进行验证，多读源码，多调试，少趟坑。

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿 (2022 最新版)

2. 劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4. 别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！