Java 如何使用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 = ?

//json输入
[{
“id”：“垃圾”，
“东西”：“东西”
},
{
“id”：“垃圾邮件”，
“东西”：“鸡蛋”
}]
//爪哇
列表条目=？

---

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

首先创建一个映射器：

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 myObjects=mapper.readValue（jsonInput，newtypereference（）{}）；

指定列表类型的另一种方法：

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

List myObjects=mapper.readValue（jsonInput，mapper.getTypeFactory（）.constructioncollectiontype（List.class，MyClass.class））；

来自

List myObjects=Arrays.asList（mapper.readValue（json，MyClass[].class））

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

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

ObjectMapper mapper=新的ObjectMapper（）；
JsonFactory f=新的JsonFactory（）；
List lstUser=null；
JsonParser jp=f.createJsonParser（新文件（“C:\\maven\\user.json”）；
TypeReference tRef=新的TypeReference（）{}；
lstUser=mapper.readValue（jp，tRef）；
for（用户：lstUser）{
System.out.println（user.toString（））；
}
}捕获（JsonGenerationException e）{
e、 printStackTrace（）；
}捕获（JsonMappingException e）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}

对于一般实施：

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

publicstaticlist-parseJsonArray（字符串json，
类（已定义其上的数组）
抛出IOException，ClassNotFoundException{
ObjectMapper mapper=新的ObjectMapper（）；
类arrayClass=（类）Class.forName（“[L”+classwhicharrayIsdefined.getName（）+”；”；
T[]objects=mapper.readValue（json，arrayClass）；
返回数组.asList（对象）；
}

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

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

ObjectMapper ObjectMapper=new ObjectMapper（）；
ObjectReader=objectMapper.reader（）.forType（新类型引用（）{}）；

然后使用它：

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

List result=objectReader.readValue（inputStream）；

这里有一个实用程序，用于转换json2object或Object2json， 无论您的pojo是什么（实体T）

import java.io.IOException；
导入java.io.StringWriter；
导入java.util.List；
导入com.fasterxml.jackson.core.jsongGenerationException；
导入com.fasterxml.jackson.core.JsonParseException；
导入com.fasterxml.jackson.core.type.TypeReference；
导入com.fasterxml.jackson.databind.DeserializationFeature；
导入com.fasterxml.jackson.databind.JsonMappingException；
导入com.fasterxml.jackson.databind.ObjectMapper；
导入com.fasterxml.jackson.databind.SerializationFeature；
/**
* 
*@author TIAGO.MEDICI
* 
*/
公共类JsonUtils{
公共静态布尔值isJSONValid（字符串jsonInString）{
试一试{
最终ObjectMapper映射器=新ObjectMapper（）；
readTree（jsonInString）；
返回true；
}捕获（IOE异常）{
返回false；
}
}
公共静态字符串serializeAsJsonString（对象对象）抛出JsonGenerationException、JsonMappingException、IOException{
ObjectMapper objMapper=新的ObjectMapper（）；
enable（SerializationFeature.INDENT_输出）；
禁用（SerializationFeature.FAIL_ON_EMPTY_bean）；
StringWriter sw=新的StringWriter（）；
objMapper.writeValue（sw，object）；
返回sw.toString（）；
}
公共静态字符串serializeAsJsonString（对象对象，布尔缩进）抛出JsonGenerationException、JsonMappingException、IOException{
ObjectMapper objMapper=新的ObjectMapper（）；
如果（缩进==真）{
enable（SerializationFeature.INDENT_输出）；
禁用（SerializationFeature.FAIL_ON_EMPTY_bean）；
}
StringWriter StringWriter=新StringWriter（）；
writeValue（stringWriter，对象）；
返回stringWriter.toString（）；
}
公共静态TJSONSTRINGTOObject（字符串内容，类clazz）抛出JsonParseException、JsonMappingException、IOException{
T obj=null；
ObjectMapper objMapper=新的ObjectMapper（）；
obj=objMapper.readValue（内容、类别）；
返回obj；
}
@抑制警告（“原始类型”）
公共静态T JSONStringToObject数组（字符串内容）抛出JsonParseException、JsonMappingException、IOException{
T obj=null；
ObjectMapper mapper=新的ObjectMapper（）；
obj=mapper.readValue（内容，新类型引用（）{
});
返回obj；
}
公共静态T JSONStringToObject数组（字符串内容，类clazz）抛出JsonParseException、JsonMappingException、IOException{
T obj=null；
ObjectMapper mapper=新的ObjectMapper（）；
mapper=new ObjectMapper（）.configure（反序列化功能。接受单个值作为数组，true）；
obj=mapper.readValue（content，mapper.getTypeFactory（）.ConstructionCollectionType（List.class，clazz））；
返回obj；
}

您还可以创建一个扩展

ArrayList

的类：

公共静态类MyList扩展了ArrayList{}

然后像这样使用它：

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

List List=objectMapper.readValue（json，MyList.class）；

我无法使用，因为我的过梁不允许未经检查的投射

这是一个你可以使用的替代方案。我觉得它实际上是一个更清洁的解决方案

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

public List parseJsonArray（字符串json，类clazz）抛出JsonProcessingException{
var-tree=objectMapper.readTree（json）；
var list=new ArrayList（）；
for（JsonNode JsonNode:tree）{
add（objectMapper.treeToValue（jsonNode，clazz））；
}
退货清单；
}
List<MyClass> list = objectMapper.readValue(json, MyList.class);

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