Map->Bean

谁发的是s

import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.Converter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.Map;

public class BeanUtils {

    private static Logger logger = LoggerFactory.getLogger(BeanUtils.class);

    /**
     * 利用Introspector,PropertyDescriptor实现 Map --> Bean
     *
     * @param clazz
     * @param map
     * @param <T>
     * @return
     */
    public static <T> T transMapToBean(Class<T> clazz, Map map) {
        T obj = null;
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(clazz);
            obj = clazz.newInstance(); // 创建 JavaBean 对象

            // 给 JavaBean 对象的属性赋值
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();

            if (propertyDescriptors != null && propertyDescriptors.length > 0) {
                String propertyName = null; // javaBean属性名
                Object propertyValue = null; // javaBean属性值
                for (PropertyDescriptor property : propertyDescriptors) {
                    propertyName = property.getName();
                    if (map.containsKey(propertyName)) {
                        propertyValue = map.get(propertyName);
                        try {
                            property.getWriteMethod().invoke(obj, new Object[]{propertyValue});
                        } catch (InvocationTargetException e) {
                            logger.error("字段映射失败");
                        }
                    }
                }
                return (T) obj;
            }
        } catch (IllegalAccessException e) {
            logger.error("实例化 JavaBean 失败", e);
        } catch (IntrospectionException e) {
            logger.error("分析类属性失败", e);
        } catch (IllegalArgumentException e) {
            logger.error("映射错误", e);
        } catch (InstantiationException e) {
            logger.error("实例化 JavaBean 失败", e);
        }
        return (T) obj;
    }

    /**
     * 利用Introspector和PropertyDescriptor 将Bean --> Map
     *
     * @param obj
     */
    public static Map<String, Object> transBeanToMap(Object obj) {
        if (obj == null) {
            return null;
        }
        Map<String, Object> map = new HashMap<String, Object>();
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor property : propertyDescriptors) {
                String key = property.getName();
                // 过滤class属性
                if (!key.equals("class")) {
                    // 得到property对应的getter方法
                    Method getter = property.getReadMethod();
                    Object value = getter.invoke(obj);

                    map.put(key, value);
                }

            }
        } catch (IntrospectionException e) {
            logger.error("分析类属性失败", e);
        } catch (IllegalAccessException e) {
            logger.error("实例化 JavaBean 失败", e);
        } catch (IllegalArgumentException e) {
            logger.error("映射错误", e);
        } catch (InvocationTargetException e) {
            logger.error("调用属性的 setter 方法失败", e);
        }
        return map;
    }

    /**
     * Map --> Bean，并自动将字符串转换为时间类型
     *
     * @param map
     * @param obj
     */
    public static void transMap2Bean(Map<String, Object> map, Object obj) {
        ConvertUtils.register(new Converter() {
            @SuppressWarnings("rawtypes")
            @Override
            public Object convert(Class arg0, Object arg1) {
                if (arg1 == null) {
                    return null;
                }
                if (!(arg1 instanceof String)) {
                    logger.error("只支持字符串转换 !");
                }
                String str = (String) arg1;
                if (str.trim().equals("")) {
                    return null;
                }

                SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

                try {
                    return sd.parse(str);
                } catch (java.text.ParseException e) {
                    throw new RuntimeException(e);
                }

            }

        }, java.util.Date.class);
        if (map == null || obj == null) {
            return;
        }
        try {
            org.apache.commons.beanutils.BeanUtils.populate(obj, map);
        } catch (Exception e) {
            logger.error("Map<String,Object>转化Bean异常：", e);
        }
    }
}