首页 文章

如何使用Jackson对一系列对象进行反序列化

提问于
浏览
580

Jackson data binding documentation表示 Jackson 支持反序列化"Arrays of all supported types"但我无法弄清楚这个的确切语法 .

对于单个对象,我会这样做:

//json input
{
    "id" : "junk",
    "stuff" : "things"
}

//Java
MyClass instance = objectMapper.readValue(json, MyClass.class);

现在对于一个数组我想这样做:

//json input
[{
    "id" : "junk",
    "stuff" : "things"
},
{
    "id" : "spam",
    "stuff" : "eggs"
}]

//Java
List<MyClass> entries = ?

有人知道是否有一个神奇的缺失命令?如果没有那么解决方案是什么?

6 回答

  • 134
    try {
        ObjectMapper mapper = new ObjectMapper();
        JsonFactory f = new JsonFactory();
        List<User> lstUser = null;
        JsonParser jp = f.createJsonParser(new File("C:\\maven\\user.json"));
        TypeReference<List<User>> tRef = new TypeReference<List<User>>() {};
        lstUser = mapper.readValue(jp, tRef);
        for (User user : lstUser) {
            System.out.println(user.toString());
        }
    
    } catch (JsonGenerationException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    
  • 16

    这是一个实用程序,它可以转换为json2object或Object2json,无论你的pojo(实体T)

    import java.io.IOException;
    import java.io.StringWriter;
    import java.util.List;
    
    import com.fasterxml.jackson.core.JsonGenerationException;
    import com.fasterxml.jackson.core.JsonParseException;
    import com.fasterxml.jackson.core.type.TypeReference;
    import com.fasterxml.jackson.databind.DeserializationFeature;
    import com.fasterxml.jackson.databind.JsonMappingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.SerializationFeature;
    
    /**
     * 
     * @author TIAGO.MEDICI
     * 
     */
    public class JsonUtils {
    
        public static boolean isJSONValid(String jsonInString) {
            try {
                final ObjectMapper mapper = new ObjectMapper();
                mapper.readTree(jsonInString);
                return true;
            } catch (IOException e) {
                return false;
            }
        }
    
        public static String serializeAsJsonString(Object object) throws JsonGenerationException, JsonMappingException, IOException {
            ObjectMapper objMapper = new ObjectMapper();
            objMapper.enable(SerializationFeature.INDENT_OUTPUT);
            objMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
            StringWriter sw = new StringWriter();
            objMapper.writeValue(sw, object);
            return sw.toString();
        }
    
        public static String serializeAsJsonString(Object object, boolean indent) throws JsonGenerationException, JsonMappingException, IOException {
            ObjectMapper objMapper = new ObjectMapper();
            if (indent == true) {
                objMapper.enable(SerializationFeature.INDENT_OUTPUT);
                objMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
            }
    
            StringWriter stringWriter = new StringWriter();
            objMapper.writeValue(stringWriter, object);
            return stringWriter.toString();
        }
    
        public static <T> T jsonStringToObject(String content, Class<T> clazz) throws JsonParseException, JsonMappingException, IOException {
            T obj = null;
            ObjectMapper objMapper = new ObjectMapper();
            obj = objMapper.readValue(content, clazz);
            return obj;
        }
    
        @SuppressWarnings("rawtypes")
        public static <T> T jsonStringToObjectArray(String content) throws JsonParseException, JsonMappingException, IOException {
            T obj = null;
            ObjectMapper mapper = new ObjectMapper();
            obj = mapper.readValue(content, new TypeReference<List>() {
            });
            return obj;
        }
    
        public static <T> T jsonStringToObjectArray(String content, Class<T> clazz) throws JsonParseException, JsonMappingException, IOException {
            T obj = null;
            ObjectMapper mapper = new ObjectMapper();
            mapper = new ObjectMapper().configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
            obj = mapper.readValue(content, mapper.getTypeFactory().constructCollectionType(List.class, clazz));
            return obj;
        }
    
  • 1259

    对于通用实现:

    public static <T> List<T> parseJsonArray(String json,
                                             Class<T> classOnWhichArrayIsDefined) 
                                             throws IOException, ClassNotFoundException {
       ObjectMapper mapper = new ObjectMapper();
       Class<T[]> arrayClass = (Class<T[]>) Class.forName("[L" + classOnWhichArrayIsDefined.getName() + ";");
       T[] objects = mapper.readValue(json, arrayClass);
       return Arrays.asList(objects);
    }
    
  • 5

    来自Eugene Tskhovrebov

    List<MyClass> myObjects = Arrays.asList(mapper.readValue(json, MyClass[].class))
    

    这个解决方案对我来说似乎是最好的

  • 1

    首先创建一个映射器:

    import com.fasterxml.jackson.databind.ObjectMapper;// in play 2.3
    ObjectMapper mapper = new ObjectMapper();
    

    作为数组:

    MyClass[] myObjects = mapper.readValue(json, MyClass[].class);
    

    如清单:

    List<MyClass> myObjects = mapper.readValue(jsonInput, new TypeReference<List<MyClass>>(){});
    

    另一种指定List类型的方法:

    List<MyClass> myObjects = mapper.readValue(jsonInput, mapper.getTypeFactory().constructCollectionType(List.class, MyClass.class));
    
  • 5

    首先创建一个线程安全的ObjectReader实例 .

    ObjectMapper objectMapper = new ObjectMapper();
    ObjectReader objectReader = objectMapper.reader().forType(new TypeReference<List<MyClass>>(){});
    

    然后使用它:

    List<MyClass> result = objectReader.readValue(inputStream);
    

相关问题