Java基基

Java Bean 转 Map 的巨坑，注意了！！！

点击上方“Java基基”，选择“设为星标”

做积极的人，而不是积极废人！

每天 14:00 更新文章，每天掉亿点点头发...

源码精品专栏

原创 | Java 2021 超神之路，很肝~
中文详细注释的开源项目
RPC 框架 Dubbo 源码解析
网络应用框架 Netty 源码解析
消息中间件 RocketMQ 源码解析
数据库中间件 Sharding-JDBC 和 MyCAT 源码解析
作业调度中间件 Elastic-Job 源码解析
分布式事务中间件 TCC-Transaction 源码解析
Eureka 和 Hystrix 源码解析
Java 并发源码

来源：juejin.cn/post/

7118073840999071751

一、背景
二、那些坑
- 2.0 测试对象
- 2.1 JSON 反序列化了类型丢失
- 2.2 BeanMap 转换属性名错误
三、解决办法
- 3.1 解决方案
- 3.2 原理解析
四、总结

一、背景

有些业务场景下需要将 Java Bean 转成 Map 再使用。本以为很简单场景，但是坑很多。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

项目地址：https://gitee.com/zhijiantianya/ruoyi-vue-pro

视频教程：https://doc.iocoder.cn/video/

二、那些坑

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 依赖：



    com.alibaba
    fastjson
    2.0.8

示例代码：

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 map =  JSON.parseObject(json, new TypeReference>(){});

        System.out.println(map);
    }
}

结果打印：

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

调试截图：

Java Bean 转 Map 的巨坑，注意了！！！_第2张图片

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

Java Bean 转 Map 的巨坑，注意了！！！_第3张图片

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 版本：



    commons-beanutils
    commons-beanutils
    1.9.4

代码示例：

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);
    }
}

调试截图：

Java Bean 转 Map 的巨坑，注意了！！！_第4张图片

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

原因分析：

/**
 * Constructs a new BeanMap that operates on the
 * specified bean.  If the given bean is null, 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  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 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 Bean 转 Map 的巨坑，注意了！！！_第5张图片

经过分析会发现 java.beans.Introspector#getTargetPropertyInfo 方法是字段解析的关键

Java Bean 转 Map 的巨坑，注意了！！！_第6张图片

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

然后去构造 PropertyDescriptor:

/**
 * Creates PropertyDescriptor 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.
 * 
 * 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 依赖



        cglib
        cglib-nodep
        3.2.12

代码示例：

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);
    }
}

结果展示：

Java Bean 转 Map 的巨坑，注意了！！！_第7张图片

我们发现类型对了，但是属性名依然不对。

关键代码：net.sf.cglib.core.ReflectUtils#getBeanGetters 底层也会用到 java.beans.Introspector#decapitalize 所以属性名存在一样的问题就不足为奇了。

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

项目地址：https://gitee.com/zhijiantianya/yudao-cloud

视频教程：https://doc.iocoder.cn/video/

三、解决办法

3.1 解决方案

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

maven 依赖：



    org.apache.dubbo
    dubbo
    3.0.9

示例代码：

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 Bean 转 Map 的巨坑，注意了！！！_第8张图片

Java Visualizer 效果：

Java Bean 转 Map 的巨坑，注意了！！！_第9张图片

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 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