Json 转换地图<；字符串，字符串>；到波乔

我一直在关注Jackson，但似乎我必须将映射转换为JSON，然后将生成的JSON转换为POJO

---

有没有办法将映射直接转换为POJO？

是的，完全可以避免中间转换为JSON。使用像这样的深度复制工具，可以将贴图直接转换为POJO。下面是一个简单的例子：

示例POJO：

public class MyPojo implements Serializable {
    private static final long serialVersionUID = 1L;

    private String id;
    private String name;
    private Integer age;
    private Double savings;

    public MyPojo() {
        super();
    }

    // Getters/setters

    @Override
    public String toString() {
        return String.format(
                "MyPojo[id = %s, name = %s, age = %s, savings = %s]", getId(),
                getName(), getAge(), getSavings());
    }
}

示例转换代码：

public class CopyTest {
    @Test
    public void testCopyMapToPOJO() throws Exception {
        final Map<String, String> map = new HashMap<String, String>(4);
        map.put("id", "5");
        map.put("name", "Bob");
        map.put("age", "23");
        map.put("savings", "2500.39");
        map.put("extra", "foo");

        final DozerBeanMapper mapper = new DozerBeanMapper();
        final MyPojo pojo = mapper.map(map, MyPojo.class);
        System.out.println(pojo);
    }
}

公共类CopyTest{
@试验
public void testCopyMapToPOJO（）引发异常{
最终映射=新的HashMap（4）；
地图放置（“id”、“5”）；
地图。放置（“名称”、“鲍勃”）；
地图放置（“年龄”、“23”）；
map.put（“储蓄”、“2500.39”）；
地图放置（“额外”、“foo”）；
最终DozerBeanMapper=新DozerBeanMapper（）；
final-MyPojo-pojo=mapper.map（map，MyPojo.class）；
系统输出打印LN（pojo）；
}
}

输出：

MyPojo[id=5，name=Bob，年龄=23，储蓄=2500.39]

---

注意：如果您将源映射更改为

map

，则可以复制任意深度嵌套的属性（使用

map

只能获得一个级别）。

使用Jackson也可以实现这一点。（自从您考虑使用jackson后，它似乎更舒适了）

使用ObjectMapper的方法：

无需转换为JSON字符串或其他内容；直接转换速度要快得多。

具有以下功能的解决方案：

---

我测试了Jackson和BeanUtils，发现BeanUtils速度更快。
在我的机器（Windows8.1，JDK1.7）中，我得到了这个结果

BeanUtils t2-t1 = 286
Jackson t2-t1 = 2203

公共类MainMapToPOJO{
公共静态最终整数循环最大计数=1000；
公共静态void main（字符串[]args）{
Map Map=newhashmap（）；
map.put（“成功”，true）；
map.put（“数据”、“测试字符串”）；
runBeanUtilsPopulate（地图）；
runJacksonMapper（地图）；
}
私有静态void runBeanUtilsPopulate（映射）{
long t1=System.currentTimeMillis（）；
对于（int i=0；i

如果类中有泛型类型，则应将

TypeReference

与

convertValue（）

一起使用

final ObjectMapper mapper=new ObjectMapper（）；
final MyPojo pojo=mapper.convertValue（映射，新类型引用（）{}）；

您还可以使用它将pojo转换为

java.util.Map

返回

final ObjectMapper mapper=new ObjectMapper（）；
final Map=mapper.convertValue（pojo，new-TypeReference（）{}）；

将Map转换为POJO示例。请注意，Map键包含下划线，字段变量为驼峰

User.class POJO

import com.fasterxml.jackson.annotation.JsonProperty；
导入龙目数据；
@资料
公共类用户{
@JsonProperty（“用户名”）
私有字符串用户名；
@JsonProperty（“传递单词”）
私有字符串密码；
}

App.class将测试该示例

import java.util.HashMap；
导入java.util.Map；
导入com.fasterxml.jackson.databind.ObjectMapper；
公共类应用程序{
公共静态void main（字符串[]args）{
Map info=newhashmap（）；
信息输入（“用户名”、“Q10Viking”）；
信息输入（“传递单词”、“123456”）；
ObjectMapper mapper=新的ObjectMapper（）；
User User=mapper.convertValue（info，User.class）；
System.out.println（“------------------------------------”；
System.out.println（用户）；
}
}
/**输出
-------------------------------
用户（用户名=Q10Viking，密码=123456）
*/

@Hamedz 如果使用多个数据，请使用Jackson进行转换 轻数据，使用apache。。。 测试用例：

导入java.lang.reflect.InvocationTargetException；
导入java.util.HashMap；
导入java.util.Map；
导入org.apache.commons.beanutils.beanutils；
导入com.fasterxml.jackson.databind.ObjectMapper；
导入lombok.allargsconstuctor；
导入龙目数据；
导入lombok.noargsconstuctor；
公共类TestPerf{
公共静态最终整数循环最大计数=1000；
公共静态void main（字符串[]args）{
Map Map=newhashmap（）；
map.put（“成功”，true）；
地图。放置（“数字”，1000）；
地图放置（“更长”，1000L）；
map.put（“倍增器”，1000D）；
put（“data1”、“testString”）；
put（“data2”、“testString”）；
put（“data3”、“testString”）；
put（“data4”、“testString”）；
map.put（“data5”、“testString”）；
map.put（“data6”、“testString”）；
put（“data7”、“testString”）；
map.put（“data8”、“testString”）；
put（“data9”、“testString”）；
map.put（“data10”、“testString”）；
runBeanUtilsPopulate（地图）；
runJacksonMapper（地图）；
}
私有静态void runBeanUtilsPopulate（映射）{
long t1=System.currentTimeMillis（）；
对于（int i=0；iGson gson = new Gson();
JsonElement jsonElement = gson.toJsonTree(map);
MyPojo pojo = gson.fromJson(jsonElement, MyPojo.class);

BeanUtils t2-t1 = 286
Jackson t2-t1 = 2203

public class MainMapToPOJO {

public static final int LOOP_MAX_COUNT = 1000;

public static void main(String[] args) {
    Map<String, Object> map = new HashMap<>();
    map.put("success", true);
    map.put("data", "testString");

    runBeanUtilsPopulate(map);

    runJacksonMapper(map);
}

private static void runBeanUtilsPopulate(Map<String, Object> map) {
    long t1 = System.currentTimeMillis();
    for (int i = 0; i < LOOP_MAX_COUNT; i++) {
        try {
            TestClass bean = new TestClass();
            BeanUtils.populate(bean, map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
    long t2 = System.currentTimeMillis();
    System.out.println("BeanUtils t2-t1 = " + String.valueOf(t2 - t1));
}

private static void runJacksonMapper(Map<String, Object> map) {
    long t1 = System.currentTimeMillis();
    for (int i = 0; i < LOOP_MAX_COUNT; i++) {
        ObjectMapper mapper = new ObjectMapper();
        TestClass testClass = mapper.convertValue(map, TestClass.class);
    }
    long t2 = System.currentTimeMillis();
    System.out.println("Jackson t2-t1 = " + String.valueOf(t2 - t1));
}}

import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;

import com.fasterxml.jackson.databind.ObjectMapper;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

public class TestPerf {

    public static final int LOOP_MAX_COUNT = 1000;

    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<>();
        map.put("success", true);
        map.put("number", 1000);
        map.put("longer", 1000L);
        map.put("doubler", 1000D);
        map.put("data1", "testString");
        map.put("data2", "testString");
        map.put("data3", "testString");
        map.put("data4", "testString");
        map.put("data5", "testString");
        map.put("data6", "testString");
        map.put("data7", "testString");
        map.put("data8", "testString");
        map.put("data9", "testString");
        map.put("data10", "testString");

        runBeanUtilsPopulate(map);

        runJacksonMapper(map);
    }

    private static void runBeanUtilsPopulate(Map<String, Object> map) {
        long t1 = System.currentTimeMillis();
        for (int i = 0; i < LOOP_MAX_COUNT; i++) {
            try {
                TestClass bean = new TestClass();
                BeanUtils.populate(bean, map);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
        long t2 = System.currentTimeMillis();
        System.out.println("BeanUtils t2-t1 = " + String.valueOf(t2 - t1));
    }

    private static void runJacksonMapper(Map<String, Object> map) {
        long t1 = System.currentTimeMillis();
        for (int i = 0; i < LOOP_MAX_COUNT; i++) {
            ObjectMapper mapper = new ObjectMapper();
            TestClass testClass = mapper.convertValue(map, TestClass.class);
        }
        long t2 = System.currentTimeMillis();
        System.out.println("Jackson t2-t1 = " + String.valueOf(t2 - t1));
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class TestClass {
        private Boolean success;
        private Integer number;
        private Long longer;
        private Double doubler;
        private String data1;
        private String data2;
        private String data3;
        private String data4;
        private String data5;
        private String data6;
        private String data7;
        private String data8;
        private String data9;
        private String data10;

    }
}

    public static <T> T convert(Map<String, Object> aMap, Class<T> t) {
        try {
            return objectMapper
                    .convertValue(aMap, objectMapper.getTypeFactory().constructType(t));
        } catch (Exception e) {
            log.error("converting failed! aMap: {}, class: {}", getJsonString(aMap), t.getClass().getSimpleName(), e);
        }
        return null;
    }

 ObjectMapper objectMapper = new ObjectMapper();
 //if all properties are not in class use this
 objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 final MyPojo pojo =     objectMapper.convertValue(map, MyPojo.class);