Jackson - Deserialize using generic class

java

deserialize

jackson

generics

byAnton Shumikhin·Sep 18, 2024

You can use the TypeReference from Jackson library to deserialize JSON into generic classes. Here's a quick example:

String jsonList = "[{\"prop\":\"value\"}]"; // Let's pretend this fancy JSON is from Elon's Mars mission
ObjectMapper mapper = new ObjectMapper(); // Meet our new friend, Mr. ObjectMapper.
List<MyClass> myList = mapper.readValue(jsonList, new TypeReference<List<MyClass>>() {}); // Voila! JSON metamorphosed into Java!

You can replace MyClass with the class you're focusing on.

Wrestling with complex generics

For complex types like Map<String, List<MyClass>>, construct a JavaType instead:

JavaType javaType = mapper.getTypeFactory().constructParametricType(
   Map.class, String.class, mapper.getTypeFactory().constructCollectionType(List.class, MyClass.class));
Map<String, List<MyClass>> myMap = mapper.readValue(jsonMap, javaType);

Same goes for custom generic types, such as Data<MyClass>:

JavaType dataType = mapper.getTypeFactory().constructParametricType(Data.class, MyClass.class);
Data<MyClass> data = mapper.readValue(json, dataType); // Dumbledore had pensieve, we have dataType!

Tip: Consider using @JsonTypeInfo on your classes to embed type info in JSON, making deserialization a breeze.

Addressing advanced generic deserialization

Handling multiple type parameters

Multitasking with multiple type parameters? Have no fear, TypeFactory.constructParametricType is here:

JavaType customType = mapper.getTypeFactory().constructParametricType(CustomClass.class, KeyClass.class, ValueClass.class);
CustomClass<KeyClass, ValueClass> customObject = mapper.readValue(json, customType); // Mission accomplished! 🚀

Ensuring correct resolution of types

Type can be a tricky customer. Always make sure it's known during deserialization:

JavaType mapType = mapper.getTypeFactory().constructMapType(HashMap.class, String.class, MyClass.class);
HashMap<String, MyClass> myMap = mapper.readValue(jsonMap, mapType); // JSON Map unlocked! 🗺️

Using generic type bounds

Here's a trick to deserialize with generic type bounds:

public class BoundedTypeReference<T extends MyBound> extends TypeReference<T> {} // Our BoundedTypeReference is ready to play!

BoundedTypeReference<MyClass> typeRef = new BoundedTypeReference<>() {};
MyClass myObject = mapper.readValue(jsonString, typeRef); // BoundedTypeReference for the win!

Leveraging Jackson's type resolution

Dealing with parameterized JavaType

Create parameterized JavaType instances for your classes:

JavaType resolvedType = objectMapper.getTypeFactory().constructParametricType(Container.class, ActualType.class);
Container<ActualType> container = objectMapper.readValue(jsonData, resolvedType); // Jackson's secret sauce 🦉

Addressing generic subtypes

Scotty, we have a BaseClass<SubClass>.

JavaType baseType = mapper.getTypeFactory().constructParametricType(BaseClass.class, SubClass.class);
BaseClass<SubClass> myGenericObject = mapper.readValue(jsonString, baseType); // SubClass has been teleported! 🚀

Context awareness

Class type must be correct even in a non-static context. You might have to employ some ninja tricks here.

Visualization: Unpacking the Process

Picture this: We have our raw JSON data, a jumbled mess of { and }. Here comes Jackson, the savvy interpreter, identifying the structure. This JSON is then parsed by the Type Reference and it transforms into Generic<T> Class:

Raw JSON 👾 → 🤖 Jackson 🤖 → 🎩 Generic<T> Class ✨

Raw JSON 👾 = `{"name":"Widget","quantity":5}`
Type Ref. 🎩 = `new TypeReference<Generic<Widget>>() {}`
Transformed 🎉 = Widget{name='Widget', quantity=5}

It's like being a magician, your Type Reference is your wand turning the JSON rabbit into Java bunny.