如何使用Jackson来反序列化对象数组

Jackson数据绑定文档表明Jackson支持反序列化“所有受支持类型的数组”，但是我无法确定确切的语法。

对于单个对象，我可以这样做：

//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 = ?

任何人都知道是否缺少一个不可思议的命令？如果没有，那么解决方案是什么？

我更喜欢Google的GSON库来处理JSON。值得一看的是，如果您还没有尝试过的话...使它的使用变得非常容易和直观。

FWIW使用Gson解决此特定问题的可能解决方案几乎与使用Jackson的数据绑定API的解决方案相同。

Gweebz-也许您想解释一下为什么您觉得GSON是更好的选择（与Jackson相比）？

#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<MyClass> myObjects = mapper.readValue(jsonInput, mapper.getTypeFactory().constructCollectionType(List.class, MyClass.class));

需要特别注意的是，如果在解析时遇到诸如JsonMappingException之类的错误：没有找到适合类型的构造函数，则意味着您需要向类中添加默认构造函数，并为我修复了私有的无参数构造函数。

–SyntaxRules
13年8月9日在16:07

如果您有显式构造函数，则需要@SyntaxRules添加显式构造函数-否则，编译器会自动创建公共的“空”构造函数。好点子。另一个常见的问题是内部类必须是静态的-否则它们永远不会具有零参数构造函数。

– StaxMan
13年8月20日在0:09

顺便说一句，List myObjects = Arrays.asList（mapper.readValue（json，MyClass []。class））比TypeRefence的运行速度快10倍。

–user1303718
2014年6月5日12:44

我正在寻找通用类型的版本。

– Stephane
2014年9月1日下午13:54

作为对我上面的评论的回应，首先将json字符串解析为jsonNode，然后按如下方式访问数组的属性：JsonNode jsonNode = MAPPER.readTree（json）;字符串arrayString = jsonNode.get（“ data”）。toString（）;然后按照上述@Programmer Bruce的说明进行操作。 List 源= MAPPER.readValue（arrayString，新的TypeReference >（）{}）;

–马尼纳加人
17年1月27日在17:57

#2 楼

来自Eugene Tskhovrebov

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

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

对于使用Java，Lotus Domino和Agent的人来说，这是必须走的路。我尝试了其他一些解决方案，但始终遇到ResourceNotFoundException

–约翰
17 Mar 8 '17 at 14:38

此解决方案可能需要在上述答案的注释中添加SyntaxRules，因为这对我来说是必需的。我只是想补充一点，以免丢失。

–抢夺
17年4月19日在9:04

或Arrays.asList（Json.fromJson（json.get（“ fieldName”），MyClass []。class））

– Al-Mothafar
17年9月14日在7:07

或List myObjects = Arrays.asList（mapper.treeToValue（jsonNode.get（“ fieldName”），MyClass []。class））

–科林·克劳尔
18-3-3在23:56

@CollinKrawll objectmapper.treetovalue做什么？

– Eswar
18/09/20在9:39

#3 楼

对于通用实现：

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

Class 的不错的构造。没看过您在哪里找到有关此信息？

– Roeland Van Heddegem
18年1月18日在15:07

那就是应该用绿色标记标记的答案。

– Mariusz Lotko
8月31日9:45

#4 楼

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

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

，然后使用它：

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

我们确实得到了-com.fasterxml.jackson.databind.JsonMappingException：无法从START_OBJECT令牌中反序列化java.util.ArrayList的实例，位于[Source：java.io.FileInputStream@33fec21;行：1，列：1]

– Dinesh Kumar
1月7日在16:12

#5 楼

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

#6 楼

这是一个用于转换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;
    }

#7 楼

我无法使用此答案，因为我的短毛绒不允许未经检查的演员。

这里是您可以使用的替代方法。我觉得这实际上是一种更清洁的解决方案。

public <T> List<T> parseJsonArray(String json, Class<T> clazz) throws JsonProcessingException {
  var tree = objectMapper.readTree(json);
  var list = new ArrayList<T>();
  for (JsonNode jsonNode : tree) {
    list.add(objectMapper.treeToValue(jsonNode, clazz));
  }
  return list;
}

#8 楼

您还可以创建一个扩展ArrayList的类：

public static class MyList extends ArrayList<Myclass> {}

，然后像这样使用它：

List<MyClass> list = objectMapper.readValue(json, MyList.class);

编程黑洞网