在Java项目开发过程中，经常遇到 JavaBean 实体转成Map对象，或者Map对象转成JavaBean实体的需求，这里分享个支持驼峰命名的JavaBean与Map对象互转的方法。

将Map对象转化为 java Bean

 /**
 * 将 Map对象转化为JavaBean
 */
public  static  <T> T convertMap2Bean(Map<String, Object> map,  Class <T> T)
    throws  Exception  {
    if(CollectionUtility.isEmpty(map)){
        return null;
    }
    //获取map中所有的key值，全部更新成大写，添加到keys集合中,与 mybatis 中驼峰命名匹配
    Object mvalue = null;
    Map<String, Object> newMap = new HashMap<>();
     iterator <Entry<String, Object>> it = map.entrySet().iterator();
    while (it.hasNext()) {
         String  key = it.next().getKey();
        mvalue = map.get(key);
        if (key.indexOf(CharacterConstant.UNDERLINE) != -1) {
            key = key.replaceAll(CharacterConstant.UNDERLINE, "");
        }
        newMap.put(key.toUpperCase(Locale.US), mvalue);
    }
    
    BeanInfo beanInfo = Introspector.getBeanInfo(T);
    T bean = T.newInstance();
    PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
    for (int i = 0, n = propertyDescriptors.length; i < n; i++) {
        PropertyDescriptor descriptor = propertyDescriptors[i];
        String propertyName = descriptor.getName();
        String upperPropertyName = propertyName.toUpperCase();
        if (newMap.keySet().contains(upperPropertyName)) {
            Object value = newMap.get(upperPropertyName);
            BeanUtils.copyProperty(bean, propertyName, value);
        }
    }
    return bean;
}  

将JavaBean转化为Map对象

 /**
 * 将一个 JavaBean 对象转化为一个 Map 
 */
public static Map<String, Object> convertBean2Map(Object bean)
    throws IntrospectionException, IllegalAccessException, InvocationTargetException {
    Class<?  extends  Object> type = bean.getClass();
    Map<String, Object> returnMap = new HashMap<>();
    BeanInfo beanInfo = Introspector.getBeanInfo(type);
    PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
    for (int i = 0; i < propertyDescriptors.length; i++) {
        PropertyDescriptor descriptor = propertyDescriptors[i];
        String propertyName = descriptor.getName();
         if  (!"class".equals(propertyName)) {
            Method readMethod = descriptor.getReadMethod();
            Object result = readMethod.invoke(bean, new Object[0]);
            if (result != null) {
                returnMap.put(propertyName, result);
            }
            else {
                returnMap.put(propertyName, null);
            }
        }
    }
    return returnMap;
}  

完整的转换类

 import com.base.infrastructure.constant.CharacterConstant;
import com.base.infrastructure.log.LoggerManager;
import org.apache.commons.beanutils.BeanUtils;

import  java.beans .BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import  Java .beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
import java.util.Map.Entry;

/**
 * Map 对象与 JavaBean 对象互转工具类 
 */
public class BeanToMapUtil {

     private  BeanToMapUtil() {
    }
    
    /**
     * 将 Map对象转化为JavaBean
     * @param map
     * @param T
     * @return
     * @throws Exception
     */
    public static <T> T convertMap2Bean(Map<String, Object> map, Class<T> T)
        throws Exception {
        if(CollectionUtility.isEmpty(map)){
            return null;
        }
        //获取map中所有的key值，全部更新成大写，添加到keys集合中,与mybatis中驼峰命名匹配
        Object mvalue = null;
        Map<String, Object> newMap = new HashMap<>();
        Iterator<Entry<String, Object>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            String key = it.next().getKey();
            mvalue = map.get(key);
            if (key.indexOf(CharacterConstant.UNDERLINE) != -1) {
                key = key.replaceAll(CharacterConstant.UNDERLINE, "");
            }
            newMap.put(key.toUpperCase(Locale.US), mvalue);
        }
        BeanInfo beanInfo = Introspector.getBeanInfo(T);
        T bean = T.newInstance();
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        for (int i = 0, n = propertyDescriptors.length; i < n; i++) {
            PropertyDescriptor descriptor = propertyDescriptors[i];
            String propertyName = descriptor.getName();
            String upperPropertyName = propertyName.toUpperCase();
            if (newMap.keySet().contains(upperPropertyName)) {
                Object value = newMap.get(upperPropertyName);
                BeanUtils.copyProperty(bean, propertyName, value);
            }
        }
        return bean;
    }
    
    /**
     * 将一个 JavaBean 对象转化为一个 Map 
     * @param bean
     * @return
     * @throws IntrospectionException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    public static Map<String, Object> convertBean2Map(Object bean)
        throws IntrospectionException, IllegalAccessException, InvocationTargetException {
        Class<? extends Object> type = bean.getClass();
        Map<String, Object> returnMap = new HashMap<>();
        BeanInfo beanInfo = Introspector.getBeanInfo(type);
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        for (int i = 0; i < propertyDescriptors.length; i++) {
            PropertyDescriptor descriptor = propertyDescriptors[i];
            String propertyName = descriptor.getName();
            if (!"class".equals(propertyName)) {
                Method readMethod = descriptor.getReadMethod();
                Object result = readMethod.invoke(bean, new Object[0]);
                if (result != null) {
                    returnMap.put(propertyName, result);
                }
                else {
                    returnMap.put(propertyName, null);
                }
            }
        }
        return returnMap;
    }
    
    /**
     * 将 List<Map>对象转化为List<JavaBean>
     * @param listMap
     * @param T
     * @return
     * @throws Exception
     */
    public static <T> List<T> convertListMap2ListBean(List<Map<String, Object>> listMap, Class<T> T)
        throws Exception {
        List<T> beanList = new ArrayList<>();
        if (listMap != null && !listMap.isEmpty()) {
            for (int i = 0, n = listMap.size(); i < n; i++) {
                Map<String, Object> map = listMap.get(i);
                T bean = convertMap2Bean(map, T);
                beanList.add(bean);
            }
            return beanList;
        }
        return beanList;
    }
    
    /**
     * 将 List<JavaBean>对象转化为List<Map>
     * @param beanList
     * @return
     * @throws Exception
     */
    public static <T> List<Map<String, Object>> convertListBean2ListMap(List<T> beanList, Class<T> T) {
        List<Map<String, Object>> mapList = new ArrayList<>();
        try {
            for (int i = 0, n = beanList.size(); i < n; i++) {
                Object bean = beanList.get(i);
                Map<String, Object> map = convertBean2Map(bean);
                mapList.add(map);
            }
        }
        catch (Exception e) {
            LoggerManager.error(T, e, "将 List<JavaBean>对象转化为List<Map>失败, beanList:{}", beanList);
            return mapList;
        }
        return mapList;
    }
}