JAVA Map转换为实体类和实体类转换为MAP

朴灿烈づ我的快乐病毒、 2022-05-22 13:20 526阅读 0赞

package com.ruiguang.tools;  
  
  
import java.beans.BeanInfo;  
import java.beans.IntrospectionException;  
import java.beans.Introspector;  
import java.beans.PropertyDescriptor;  
import java.lang.reflect.Field;  
import java.lang.reflect.InvocationTargetException;  
import java.lang.reflect.Method;  
import java.lang.reflect.Modifier;  
import java.util.Date;  
import java.util.HashMap;  
import java.util.Map;  
  
  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
  
  
public class JavaBeanUtil \{  
private static Logger logger = LoggerFactory.getLogger(JavaBeanUtil.class);  
  
  
  
  
    /\*\*  
     \* 实体类转map  
     \* @param obj  
     \* @return  
     \*/  
    public static Map<String, Object> convertBeanToMap(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);  
                    if(null==value)\{  
                        map.put(key,"");  
                    \}else\{  
                        map.put(key,value);  
                    \}  
                \}  
  
  
  
  
            \}  
        \} catch (Exception e) \{  
            logger.error("convertBean2Map Error \{\}" ,e);  
        \}  
        return map;  
    \}  
  
  
  
  
    /\*\*  
     \* map 转实体类  
     \* @param clazz  
     \* @param map  
     \* @param <T>  
     \* @return  
     \*/  
    public static <T> T convertMapToBean(Class<T> clazz, Map<String,Object> map) \{  
        T obj = null;  
        try \{  
            BeanInfo beanInfo = Introspector.getBeanInfo(clazz);  
            obj = clazz.newInstance(); // 创建 JavaBean 对象  
  
  
  
  
            // 给 JavaBean 对象的属性赋值  
            PropertyDescriptor\[\] propertyDescriptors = beanInfo.getPropertyDescriptors();  
            for (int i = 0; i < propertyDescriptors.length; i++) \{  
                PropertyDescriptor descriptor = propertyDescriptors\[i\];  
                String propertyName = descriptor.getName();  
                if (map.containsKey(propertyName)) \{  
                    // 下面一句可以 try 起来，这样当一个属性赋值失败的时候就不会影响其他属性赋值。  
                    Object value = map.get(propertyName);  
                    if ("".equals(value)) \{  
                        value = null;  
                    \}  
                    Object\[\] args = new Object\[1\];  
                    args\[0\] = value;  
                    descriptor.getWriteMethod().invoke(obj, args);  
  
  
  
  
                \}  
            \}  
        \} catch (IllegalAccessException e) \{  
            logger.error("convertMapToBean 实例化JavaBean失败 Error\{\}" ,e);  
        \} catch (IntrospectionException e) \{  
            logger.error("convertMapToBean 分析类属性失败 Error\{\}" ,e);  
        \} catch (IllegalArgumentException e) \{  
            logger.error("convertMapToBean 映射错误 Error\{\}" ,e);  
        \} catch (InstantiationException e) \{  
            logger.error("convertMapToBean 实例化 JavaBean 失败 Error\{\}" ,e);  
        \}catch (InvocationTargetException e)\{  
            logger.error("convertMapToBean字段映射失败 Error\{\}" ,e);  
        \}catch (Exception e)\{  
            logger.error("convertMapToBean Error\{\}" ,e);  
        \}  
        return (T) obj;  
    \}  
    //将map通过反射转化为实体  
    public static   Object MapToModel(Map<String,Object> map,Object o) throws Exception\{  
        if (!map.isEmpty()) \{  
            for (String k : map.keySet()) \{  
                Object v =null;  
                if (!k.isEmpty()) \{  
                    v = map.get(k);  
                \}  
                Field\[\] fields = null;  
                fields = o.getClass().getDeclaredFields();  
                String clzName = o.getClass().getSimpleName();  
                for (Field field : fields) \{  
                    int mod = field.getModifiers();  
  
  
                    if (field.getName().toUpperCase().equals(k.toUpperCase())) \{  
                        field.setAccessible(true);  
  
  
                        //region--进行类型判断  
                          String type=field.getType().toString();  
                          if (type.endsWith("String"))\{  
                              if (v!=null)\{  
                                  v=v.toString();  
                              \}else \{  
                                  v="";  
                              \}  
                          \}  
                        if (type.endsWith("Date"))\{  
                            v=new Date(v.toString());  
                        \}  
                        if (type.endsWith("Boolean"))\{  
  
  
                           v=Boolean.getBoolean(v.toString());  
                        \}  
                        if (type.endsWith("int"))\{  
  
  
                            v=new Integer(v.toString());  
                        \}  
                        if (type.endsWith("Long"))\{  
  
  
                            v=new Long(v.toString());  
                        \}  
  
  
  
  
  
  
                        //endregion  
                        field.set(o, v);  
  
  
                    \}  
  
  
                \}  
  
  
            \}  
        \}  
        return o;  
    \}  
    /\*\*  
     \* 实体对象转成Map  
     \* @param obj 实体对象  
     \* @return  
     \*/  
    public static Map<String, Object> object2Map(Object obj) \{  
        Map<String, Object> map = new HashMap<>();  
        if (obj == null) \{  
            return map;  
        \}  
        Class clazz = obj.getClass();  
        Field\[\] fields = clazz.getDeclaredFields();  
        try \{  
            for (Field field : fields) \{  
                field.setAccessible(true);  
                map.put(field.getName(), field.get(obj));  
            \}  
        \} catch (Exception e) \{  
            e.printStackTrace();  
        \}  
        return map;  
    \}  
    /\*\*  
     \* Map转成实体对象  
     \* @param map map实体对象包含属性  
     \* @param clazz 实体对象类型  
     \* @return  
     \*/  
    public static Object map2Object(Map<String, Object> map, Class<?> clazz) \{  
        if (map == null) \{  
            return null;  
        \}  
        Object obj = null;  
        try \{  
            obj = clazz.newInstance();  
  
  
  
  
            Field\[\] fields = obj.getClass().getDeclaredFields();  
            for (Field field : fields) \{  
                int mod = field.getModifiers();  
                if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) \{  
                    continue;  
                \}  
                field.setAccessible(true);  
                field.set(obj, map.get(field.getName()));  
            \}  
        \} catch (Exception e) \{  
            e.printStackTrace();  
        \}   
        return obj;  
    \}  
      
    public static void main(String\[\] args) \{  
    // TODO Auto-generated method stub  
    /\*Student s = new Student();  
           s.setUserName("ZHH");  
           s.setAge("24");  
           System.out.println(object2Map(s));  
  
  
  
  
           Map<String, Object> map = new HashMap<>();  
           map.put("userName", "zhh");  
           map.put("age", "24");  
           System.out.println(map2Object(map, Student.class));\*/  
    \}  
      
  
  
\}