将Map <String,String>转换为POJO

Question

我一直在看杰克逊,但似乎我必须将Map转换为JSON,然后将结果JSON转换为POJO.

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

Answer 1

嗯,你也可以用杰克逊实现这一点.(因为你考虑使用杰克逊,它似乎更舒服).

使用ObjectMapper的convertValue方法:

final ObjectMapper mapper = new ObjectMapper(); // jackson's objectmapper
final MyPojo pojo = mapper.convertValue(map, MyPojo.class);

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

Answer 2

Gson的解决方案:

Gson gson = new Gson();
JsonElement jsonElement = gson.toJsonTree(map);
MyPojo pojo = gson.fromJson(jsonElement, MyPojo.class);

Answer 3

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

与第一个答案相同，但我使用它时遇到错误，因为我不希望将 Map 的所有属性转换为类。我也找到了objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);解决方案。

Answer 4

if you have generic types in your class you should use TypeReference with convertValue().

final ObjectMapper mapper = new ObjectMapper();
final MyPojo<MyGenericType> pojo = mapper.convertValue(map, new TypeReference<MyPojo<MyGenericType>>() {});

您也可以使用它来将 pojo 转换java.util.Map回来。

final ObjectMapper mapper = new ObjectMapper();
final Map<String, Object> map = mapper.convertValue(pojo, new TypeReference<Map<String, Object>>() {});

Answer 5

是的，绝对可以避免中间转换为 JSON。使用像Dozer这样的深度复制工具，您可以将地图直接转换为 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);
    }
}

输出：

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

注意：如果将源映射更改为 a Map<String, Object>，则可以复制任意深度的嵌套属性（Map<String, String>仅获得一层）。

Answer 6

我测试了Jackson和BeanUtils,发现BeanUtils要快得多.
在我的机器(Windows8.1,JDK1.7)中,我得到了这个结果.

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));
}}