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

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

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

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

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

/**
 * 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;
}

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

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