前言

在使用Java编程过程中，经常会遇到获取的数据为Object类型，但只是以这种方式传输，实质还是Map类型，此时就涉及到两种类型的相互转换。

强制转换

在类型转换工程中，常见的转换方式为强制转换。如(String)map.get(key),(int)map.get(key)等。但是如果接收的类型为Map，此时强转(Map<String, Object>) obj则会报出警告。

治标不治本

很多人会使用@SuppressWarnings(“unchecked”)来解决编辑器中的警告，好看是好看了。但是这用来告诉编译器忽略警告，而警告却实实在在的存在。项目的风险还是存在。

方法一

可以使用java.lang.reflect.Field类完成Obj和Map之间的相互转换.

• Object转Map类型

//Object转Map
public static Map<String, Object> getObjectToMap(Object obj) throws IllegalAccessException {
    Map<String, Object> map = new HashMap<String, Object>();
    Class<?> cla = obj.getClass();
    Field[] fields = cla.getDeclaredFields();
    for (Field field : fields) {
        field.setAccessible(true);
        String keyName = field.getName();
        Object value = field.get(obj);
        if (value == null)
            value = "";
        map.put(keyName, value);
    }
    return map;
}

• Map转Object类型

//Map转Object
public static Object getMapToObject(Map<Object, Object> map, Class<?> cla) throws Exception {
    if (map == null)
        return null;
    Object obj = cla.newInstance();
    Class<?> cla = obj.getClass();
    Field[] fields = cla.getDeclaredFields();
    for (Field field : fields) {
        int mod = field.getModifiers();
        if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
            continue;
        }
        field.setAccessible(true);
        if (map.containsKey(field.getName())) {
            field.set(obj, map.get(field.getName()));
        }
    }
    return obj;
}

通过Field类进行数据类型的转换。

方法二

通过BeanUtils工具类进行转换

//1、map转换为object

public static Object mapToObject(Map<String, Object> map, Class<?> cla)
　　　　throws Exception {
	if (map == null) 
		return null;
　　Object obj = clas.newInstance();
	org.apache.commons.beanutils.BeanUtils.populate(obj, map);
	return obj;
}

//2、object转换为map
public static Map<?, ?> objectToMap(Object obj) {
	if (obj == null) 
		return null;
	return new org.apache.commons.beanutils.BeanMap(obj);
}

总结

最后，通过调用这两个方法就可以实现Object转Map类型，Map转Object类型。

工作中经常遇到这样的场景，需要在object和map直接相互转换，这里总结一下。

我先定义一个实体类，后面介绍的几种转换方法都以这个实体类为例进行说明。

public class PersonBean {
    private String name; //姓名
    private Integer age; //年龄
    private Boolean boy; //是否男孩
    private Date birthday; //生日
}

这里尽量覆盖不同的属性类型，便于全面的测试转换方法。

第一种方法，利用反射

然后我们写个测试方法验证一下，

@Test
    public void test1() throws Exception {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("name", "fcbox");
        map.put("age", 15);
        map.put("boy", true);
        map.put("birthday", new Date());

        PersonBean person = (PersonBean)map2Object_1(map, PersonBean.class);
        System.out.println("方法1 map->object的转换结果:" + person);
        Map<String, Object> newMap = Object2Map_1(person);
        System.out.println("方法1 object->map的转换结果:" + JSON.toJSONString(newMap));
    }

输出，

方法1 map->object的转换结果:PersonBean(name=fcbox, age=15, boy=true, birthday=Wed Nov 06 14:52:57 CST 2019)
方法1 object->map的转换结果:{"birthday":1573023177881,"name":"fcbox","boy":true,"age":15}

然后我们接着做个测试，把

map.put("boy", true);

改成

map.put("boy", "true");

会报异常，

java.lang.IllegalArgumentException: Can not set java.lang.Boolean field com.pony.app.PersonBean.boy to java.lang.String
	at sun.reflect.UnsafeFieldAccessorImpl.throwSetIllegalArgumentException(UnsafeFieldAccessorImpl.java:167)
	at sun.reflect.UnsafeFieldAccessorImpl.throwSetIllegalArgumentException(UnsafeFieldAccessorImpl.java:171)
	at sun.reflect.UnsafeObjectFieldAccessorImpl.set(UnsafeObjectFieldAccessorImpl.java:81)
	at java.lang.reflect.Field.set(Field.java:758)
	at com.pony.test.Map2ObjectTest.map2Object_1(Map2ObjectTest.java:66)
	at com.pony.test.Map2ObjectTest.test1(Map2ObjectTest.java:33)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:483)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
	at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
	at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
	at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)
方法1 map->object的转换结果:PersonBean(name=fcbox, age=15, boy=null)

你可以先记住这个结论，继续往下看。

第二种方法，利用commons.BeanUtils

示例代码如下：

public static Object map2Object_2(Map<String, Object> map, Class<?> clazz) {
        if (map == null) {
            return null;
        }
        Object obj = null;
        try {
            obj = clazz.newInstance();
            //这个方法会遍历map<key, value>中的key，如果bean中有这个属性，就把这个key对应的value值赋给bean的属性。
            BeanUtils.populate(obj, map);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }

    public static Map<?, ?> Object2Map_2(Object object) {
        if (object == null) {
            return null;
        }

        return new BeanMap(object);
    }

测试方法，

@Test
    public void teste2(){

        Map<String, Object> map = new HashMap<String, Object>();
        map.put("name", "tom");
        map.put("age", 15);
        map.put("boy", true);
        map.put("birthday", new Date());

        PersonBean person = (PersonBean)map2Object_2(map, PersonBean.class);
        System.out.println("方法2 map->object的转换结果:" + person);
        Map<?, ?> newMap = Object2Map_2(person);
        System.out.println("方法2 object->map的转换结果:" + JSON.toJSONString(newMap));
    }

输出，

方法2 map->object的转换结果:PersonBean(name=tom, age=15, boy=true, birthday=Wed Nov 06 14:53:47 CST 2019)
方法2 object->map的转换结果:{"birthday":1573023227193,"name":"tom","boy":true,"class":"com.pony.app.PersonBean","age":15}

然后像上个示例一样，把

map.put("boy", true);

改成

map.put("boy", "true");

你会发现依然可以正确的输出同样的结果。

从这点来看，beanutils比反射好用，它里面做了大量的转换工作，反射的方法更多需要你自己来处理。

第三种方法，json转换

这里使用 fastjson，其实用其它的组件也是可以的。

public static Object map2Object_3(Map<String, Object> map, Class<?> clazz) {
        if (map == null) {
            return null;
        }
        return JSON.parseObject(JSON.toJSONString(map), clazz);
    }

    public static Map<?, ?> Object2Map_3(Object object) {
        if (object == null) {
            return null;
        }
        return JSON.parseObject(JSON.toJSONString(object), Map.class);
    }

测试方法，

@Test
    public void test3(){

        Map<String, Object> map = new HashMap<String, Object>();
        map.put("name", "tom");
        map.put("age", 15);
        map.put("boy", true);
        map.put("birthday", new Date());

        PersonBean person = (PersonBean)map2Object_3(map, PersonBean.class);
        System.out.println("方法3 map->object的转换结果:" + person);
        Map<?, ?> newMap = Object2Map_3(person);
        System.out.println("方法3 object->map的转换结果:" + JSON.toJSONString(newMap));
    }

输出，

方法3 map->object的转换结果:PersonBean(name=tom, age=15, boy=true, birthday=Wed Nov 06 15:30:47 CST 2019)
方法3 object->map的转换结果:{"birthday":1573025447719,"name":"tom","boy":true,"age":15}

json的方法似乎也不错，它的原理是先把map转成json，然后把json转成object。而且你可以测试下，它也是可以识别 map.put("boy", "true");这种赋值方式的。

性能问题

我在上面三个测试方法上增加耗时打印，发现三个方法的性能排名是：

方法1 > 方法3 > 方法2

也就是说，方法2最耗时。当然这个不是官方结论，只是我自己本地环境测试的结果。

商品业务对象定义：Product

Product product = new Product();
product.setId(1L);
product.setName("爱他美")
product.setProductDt("2022-03-16")

第一种：通过Alibaba Fastjson实现：

pom.xml 文件依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.66</version>
</dependency>

//Object转Map
Map map = JSONObject.parseObject(JSONObject.toJSONString(product), Map.class);
Map<String,Object> map = JSONObject.parseObject(JSON.toJSONString(product));
//Map转Object
Product productDto1 = JSON.parseObject(JSON.toJSONString(map), Product.class);
Product productDto2 = JSONObject.toJavaObject(JSON.toJSONString(map), Product.class);

第二种：通过SpringBoot自带 Jackso实现

一般情况下我们引入MVC，MVC里面帮我们引入了Jackso依赖

 <!-- springboot web(MVC)-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

最终的依赖：

ObjectMapper mapper = new ObjectMapper();
//对象转map
Map m = mapper.readValue(mapper.writeValueAsString(product), Map.class);
//map转对象
Product dto = mapper.readValue(mapper.writeValueAsString(m), Product.class);

 第三种：通过Apache common Bean工具类实现

Pom.xml文件依赖

<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.9.3</version>
</dependency>

#使用org.apache.commons.beanutils.BeanMap进行转换，实现Bean转Map
Map<String, Object> map = new org.apache.commons.beanutils.BeanMap(product);

#使用org.apache.commons.beanutils.BeanUtils将map转为对象
BeanUtils.populate(product, map);

 第四种： 通过反射实现

通过反射实现Bean 转Map

//Object转Map
public static Map<String, Object> getObjectToMap(Object obj) throws IllegalAccessException {
    Map<String, Object> map = new LinkedHashMap<String, Object>();
    Class<?> clazz = obj.getClass();
    System.out.println(clazz);
    for (Field field : clazz.getDeclaredFields()) {
        field.setAccessible(true);
        String fieldName = field.getName();
        Object value = field.get(obj);
        if (value == null){
            value = "";
        }
        map.put(fieldName, value);
    }
    return map;
}

通过反射实现Map转Bean

//Map转Object
public static Object mapToObject(Map<Object, Object> map, Class<?> beanClass) throws Exception {
    if (map == null)
        return null;
    Object obj = beanClass.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);
        if (map.containsKey(field.getName())) {
            field.set(obj, map.get(field.getName()));
        }
    }
    return obj;
}