Map与object之间的转换

Map与Object之间的转换

在最近开发时遇到把Object转化成对象的问题，困扰了很久！此篇文章用于记录这次问题的记录，方便以后回顾。

本文使用的是反射实现转换的

创建一个工具类：

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
/**
 * bean与map的转换
 *
 * @author daweizai
 */
public class ReflectBeanUtils {
    /**
     * map转换成object
     *
     * @param map
     * @param beanClass
     * @return
     * @throws Exception
     */
    public static Object mapToObject(LinkedHashMap<String, String> map, Class<?> beanClass) throws Exception {
        if (map == null || map.size() <= 0) {
            return null;
        }

        Object obj = beanClass.newInstance();
/*
        //获取关联的所有类，本类以及所有父类
        List<Class> clazzs = new ArrayList<Class>();
        boolean ret = true;
        Class oo = obj.getClass();
        while (ret) {
            clazzs.add(oo);
            oo = oo.getSuperclass();
            if (oo == null || oo == Object.class) {
                break;
            }
        }
*/

        // for (int i = 0; i < clazzs.size(); i++) {
        //   Field[] fields = clazzs.get(i).getDeclaredFields();
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            int mod = field.getModifiers();
            if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
                continue;
            }
            //由字符串转换回对象对应的类型
            if (field != null) {
                field.setAccessible(true);
                field.set(obj, map.get(field.getName()));
            }
        }
//    }
        return obj;
    }

    /**
     * object转map
     *
     * @param obj
     * @return
     * @throws Exception
     */
    public static LinkedHashMap<String, Object> objectToMap(Object obj) throws Exception {
        if (obj == null) {
            return null;
        }
        Class oo = obj.getClass();
        //获取关联的所有类，本类以及所有父类
      /*boolean ret = true;
        List<Class> clazzs = new ArrayList<Class>();
        while (ret) {
            clazzs.add(oo);
            //获取父类
            oo = oo.getSuperclass();
            if (oo == null || oo == Object.class) {
                break;
            }
        }*/

        LinkedHashMap<String, Object> map = new LinkedHashMap<String, Object>();

		//for (int i = 0; i < clazzs.size(); i++) {
        //获取对象所有的字段，并保存到Filed数组中
        //Field[] fields = clazzs.get(i).getDeclaredFields();

        Field[] declaredFields = oo.getDeclaredFields();
        for (Field field : declaredFields) {
            // 获取字段修饰符 需要排除静态及final修饰的字段
            int mod = field.getModifiers();
            //过滤 static 和 final 类型
            if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
                continue;
            }
            // 强制设置为 true 即可以对字段值进行设置 防止一些方法阻碍我们对属性进行赋值
            field.setAccessible(true);
            // map 中如果包含字段名称的 key 则将对应的值放入 clazz 对象对应的字段上
            map.put(field.getName(), field.get(obj));
        }
//        }

        return map;
    }

写的有点乱，请见谅，可以吧注释掉的代码干掉（注释的代码主要是获取父类的代码）

此篇到此为止

参考文档：https://blog.51cto.com/zlfwmm/1758006