{"id":121222,"date":"2024-05-07T07:13:38","date_gmt":"2024-05-07T06:13:38","guid":{"rendered":"https:\/\/www.baeldung.com\/java-jackson-jsonnode-collection"},"modified":"2024-05-07T07:13:38","modified_gmt":"2024-05-07T06:13:38","slug":"convert-jackson-jsonnode-to-typed-collection","status":"publish","type":"post","link":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/2024\/05\/07\/convert-jackson-jsonnode-to-typed-collection\/","title":{"rendered":"Convert Jackson JsonNode to Typed Collection"},"content":{"rendered":"

\"start<\/p>\n

1. Overview<\/h2>\n
<\/div>\n

In this tutorial,\u00a0we’ll explore different methods of converting Jackson’s raw data type\u00a0JsonNode<\/em><\/a> into typed Java collections. While we can read JSON using\u00a0JsonNode<\/em> itself, converting it to a Java collection can be beneficial. Java collections provide advantages over raw JSON data such as type safety, faster processing, and availability of more type-specific operations.<\/p>\n

2. Example Setup<\/h2>\n
<\/div>\n

In our code example,\u00a0we’ll look at different ways to convert a\u00a0JsonNode<\/em>\u00a0to a\u00a0List<\/em>\u00a0or\u00a0Map<\/em>\u00a0of objects.\u00a0Let’s set up the building blocks of our example.<\/p>\n

2.1. Dependency<\/h3>\n
<\/div>\n

To start with, let’s add the\u00a0Jackson Core<\/a> dependency to the pom.xml<\/em> file:<\/p>\n

<dependency>\r\n    <groupId>com.fasterxml.jackson.core<\/groupId>\r\n    <artifactId>jackson-core<\/artifactId>\r\n    <version>2.17.0<\/version>\r\n<\/dependency>\r\n<\/code><\/pre>\n
2.2. JSON Data<\/h3>\n
<\/div>\n
Next, let’s define a JSON for our use case:<\/p>\n
{\r\n    "persons": [\r\n        {\r\n            "name": "John",\r\n            "age": 30\r\n        },\r\n        {\r\n            "name": "Alice",\r\n            "age": 25\r\n        }\r\n    ],\r\n    "idToPerson" : {\r\n        "1234": {\r\n            "name": "John",\r\n            "age": 30\r\n        },\r\n        "1235": {\r\n            "name": "Alice",\r\n            "age": 25\r\n        }\r\n    }\r\n}\r\n<\/code><\/pre>\n
In the above JSON, we have a JSON array persons<\/em>\u00a0and a JSON object\u00a0idToPerson<\/em>. We’ll\u00a0look at methods to convert them to Java collections.<\/p>\n
2.3. The DTO<\/h3>\n
<\/div>\n
Let’s define a\u00a0Person<\/em>\u00a0class that we can use in our example:<\/p>\n
public class Person {\r\n    private String name;\r\n    private int age;\r\n    \r\n    \/\/ constructors\/getters\/setters\r\n}\r\n<\/code><\/pre>\n
2.4. Converting JSON String to JsonNode<\/em><\/h3>\n
<\/div>\n
If we want to read an object from the entire JSON,\u00a0we can use the\u00a0ObjectMapper<\/em><\/a>\u00a0class of Jackson to do so:<\/p>\n
JsonNode rootNode = new ObjectMapper().readTree(jsonString);\r\nJsonNode childNode = rootNode.get("persons");\r\n<\/code><\/pre>\n
To convert the entire JSON into a\u00a0JsonNode<\/em>\u00a0object,\u00a0we use the\u00a0readTree()<\/em>\u00a0method.\u00a0We then traverse the\u00a0JsonNode<\/em>\u00a0object using the\u00a0get()<\/em> method that returns the nested object with the specified name.<\/strong><\/p>\n
3. Manual Conversion<\/h2>\n
<\/div>\n
Before checking library methods, let’s look at a way to convert a\u00a0JsonNode<\/em>\u00a0into a collection manually.<\/p>\n
3.1. Manually Converting JsonNode<\/em> to List<\/em><\/h3>\n
<\/div>\n
To convert a JsonNode<\/em> to a list, we can traverse it entry by entry and create a List<\/em> object with it:<\/p>\n
List<Person> manualJsonNodeToList(JsonNode personsNode) {\r\n    List<Person> people = new ArrayList<>();\r\n    for (JsonNode node : personsNode) {\r\n        Person person = new Person(node.get("name").asText(), node.get("age").asInt());\r\n        people.add(person);\r\n    }\r\n    return people;\r\n}\r\n<\/code><\/pre>\n
Here, we use a loop to traverse all children of the input node. This is possible only if our input node is an array.<\/p>\n
For each node,\u00a0we create a\u00a0Person<\/em> object and add it to the list. We get name<\/em> and age<\/em> from the node using the\u00a0get(fieldName)<\/em>\u00a0method.\u00a0JsonNode<\/em>\u00a0provides various methods to convert the returned value into primitive Java types.\u00a0Here,\u00a0the\u00a0asText()<\/em>\u00a0and\u00a0asInt()<\/em>\u00a0methods convert the value to\u00a0String<\/em>\u00a0and\u00a0int,<\/em>\u00a0respectively.<\/strong><\/p>\n
3.2. Manually Converting JsonNode<\/em> to Map<\/em><\/h3>\n
<\/div>\n
Let’s look at a similar conversion for the map:<\/p>\n
Map<String, Person> manualJsonNodeToMap(JsonNode idToPersonsNode) {\r\n    Map<String, Person> mapOfIdToPerson = new HashMap<>();\r\n    idToPersonsNode.fields()\r\n      .forEachRemaining(node -> mapOfIdToPerson.put(node.getKey(),\r\n        new Person(node.getValue().get("name").asText(), node.getValue().get("age").asInt())));\r\n    return mapOfIdToPerson;\r\n}\r\n<\/code><\/pre>\n
Here, we use the fields()<\/em> method to iterate over map entries.\u00a0It returns an\u00a0Iterator<Map.Entry<String, JsonNode>><\/em> object that we can process further. Next, we read each entry and put it into our Map<\/em>.<\/p>\n
4. Using Jackson’s readValue()<\/em> and convertValue()<\/em><\/h2>\n
<\/div>\n
Jackson provides multiple methods to convert\u00a0JsonNode<\/em> into Java objects. Let’s look at two of them.<\/p>\n
4.1. Using readValue()<\/em><\/h3>\n
<\/div>\n
The\u00a0readValue()<\/em>\u00a0<\/a>method can be used to convert to\u00a0List<\/em>\u00a0or\u00a0Map<\/em>\u00a0using a\u00a0TypeReference<\/em>:<\/p>\n
List<Person> readValueJsonNodeToList(JsonNode personsNode) throws IOException {\r\n    TypeReference<List<Person>> typeReferenceList = new TypeReference<List<Person>>() {};\r\n    return new ObjectMapper().readValue(personsNode.traverse(), typeReferenceList);\r\n}\r\nMap<String, Person> readValueJsonNodeToMap(JsonNode idToPersonsNode) throws IOException {\r\n    TypeReference<Map<String, Person>> typeReferenceMap = new TypeReference<Map<String, Person>>() {};\r\n    return new ObjectMapper().readValue(idToPersonsNode.traverse(), typeReferenceMap);\r\n}\r\n<\/code><\/pre>\n
First, we create a TypeReference<\/em>\u00a0object by passing the exact type we need to convert to.\u00a0We then call the\u00a0readValue()<\/em>\u00a0method where\u00a0JsonParser<\/em>\u00a0is provided by\u00a0jsonNode.traverse()<\/em>.\u00a0Using the parser,\u00a0it deserializes the node to a list or map as per the\u00a0TypeReference<\/em> we provide.<\/p>\n
4.2. Using convertValue()<\/em><\/h3>\n
<\/div>\n
Similarly,\u00a0we can use the\u00a0convertValue()<\/em>\u00a0method:<\/p>\n
List<Person> convertValueJsonNodeToList(JsonNode personsNode) {\r\n    TypeReference<List<Person>> typeReferenceList = new TypeReference<List<Person>>() {};\r\n    return new ObjectMapper().convertValue(personsNode, typeReferenceList);\r\n}\r\nMap<String, Person> convertValueJsonNodeToMap(JsonNode idToPersonsNode) {\r\n    TypeReference<Map<String, Person>> typeReferenceMap = new TypeReference<Map<String, Person>>() {};\r\n    return new ObjectMapper().convertValue(idToPersonsNode, typeReferenceMap);\r\n}\r\n<\/code><\/pre>\n
The\u00a0convertValue()<\/em> method works by first serializing the input object and then deserializing it to the desired type.<\/strong>\u00a0Therefore,\u00a0it can be used more flexibly for converting from one object to another.\u00a0For example,\u00a0we could also use it for reverse comparison from a Java object to\u00a0JsonNode<\/em>.<\/p>\n
5. Custom Deserializer<\/h2>\n
<\/div>\n
We can also provide a custom deserializer<\/a> to perform the conversion.\u00a0Let’s look at how we can define one:<\/p>\n
public class CustomPersonListDeserializer extends JsonDeserializer<List<Person>> {\r\n    @Override\r\n    public List<Person> deserialize(com.fasterxml.jackson.core.JsonParser p, \r\n      com.fasterxml.jackson.databind.DeserializationContext ctxt) throws IOException {\r\n        ObjectMapper objectMapper = (ObjectMapper) p.getCodec();\r\n        List<Person> personList = new ArrayList<>();\r\n        JsonNode personsNode = objectMapper.readTree(p);\r\n        for (JsonNode node : personsNode) {\r\n            personList.add(objectMapper.readValue(node.traverse(), Person.class));\r\n        }\r\n        return personList;\r\n    }\r\n}\r\n<\/code><\/pre>\n
Let’s look at a few important parts of the code:<\/p>\n