Convert JsonNode into POJO

java

objectmapper

jackson

jsonnode

byAlex Kataev·Nov 23, 2024

Here's the gist! Use ObjectMapper's treeToValue in Jackson for transforming a JsonNode to a POJO:

ObjectMapper mapper = new ObjectMapper();
MyClass myPojo = mapper.treeToValue(jsonNode, MyClass.class);

Voilà! jsonNode has metamorphosed into a dashing MyClass POJO in no time!

Cruising with older Jackson versions

Rolling with Jackson versions prior to 2.4? Fear not! You have the readValue method to your rescue:

ObjectMapper mapper = new ObjectMapper();
MyClass myPojo = mapper.readValue(someJsonNode.traverse(), MyClass.class);

It's like that vintage car that still rocks the scene!

Flexing with custom deserialization and configuration

For scenarios that require you to flex a bit more, custom deserializers serve as your fitness coach:

SimpleModule module = new SimpleModule();
module.addDeserializer(MyClass.class, new CustomDeserializer());
mapper.registerModule(module);

Who said you can't customize your own gym routine?

Configure your ObjectMapper like your Spotify playlist to never disappoint you:

mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

With this, unexpected properties will be like that annoyingly catchy song you always skip!

Advanced mapping strategies: Be the master

Tackling array type JsonNodes? Be a good scout and always check your types. And for those quirky types, TypeReference is your best ally:

if (jsonNode.isArray()) {
    List<MyClass> myPojos = mapper.readValue(someJsonNode.toString(),
                              new TypeReference<List<MyClass>>(){});
}

And remember! The only versioning you want is a perfect match between your data model and JSON.

Data binding: Winning the battle

Embarking on the data binding journey? Here are some concepts that could be your weapons of choice.

Parse like a pro

First off, lighting the parsing torch:

JsonParser parser = new JsonFactory().createParser(jsonString);
JsonNode node = parser.readValueAsTree();

Before this conversion kicks off, ensure the JsonNode type or face the wrath of the MismatchedInputException!

Let ObjectReader do the reading

For runtime changes made to the JsonNode, you can let the ObjectReader do the updated mapping.

ObjectReader reader = mapper.readerFor(MyClass.class);
MyClass myPojo = reader.readValue(modifiedJsonNode);

The ObjectReader is like the updated reading glasses for our old friend ObjectMapper.

Dealing with arrays and collections

Handling JSON arrays requires skill and determination:

ArrayNode arrayNode = ... // Assume an array node instance
List<MyClass> pojos = new ArrayList<>();

for (JsonNode node : arrayNode) {
    pojos.add(mapper.treeToValue(node, MyClass.class));
}

It's like eating an elephant, one bite at a time!