1. Overview
Polymorphic deserialization is a feature of Jackson, a popular JSON serialization and deserialization library for Java. It allows us to deserialize a JSON into a hierarchy of Java objects, even when the specific type is not known at compile time. The utility comes when you have a parent class and multiple subclasses, and we want to determine the actual type of the object during deserialization not to lose any information about the polymorphic nature of the object.
In this tutorial, we’ll explore how we can achieve that in two ways: using type-handling annotations to indicate the base class’s subtypes or a Reflections-based approach to scan and register all subtypes.
2. Polymorphic Deserialization Using @JsonTypeInfo with @JsonSubTypes
One of the most straightforward options is Jackson Polymorphic Type Handling Annotations.
Let’s see an implementation example where we’re going to use @JsonTypeInfo* and @JsonSubTypes to indicate subtypes of *Vehicle entity and deserialize it based on an existing property:
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "type", visible = true)
@JsonSubTypes({
@JsonSubTypes.Type(value = Vehicle.ElectricVehicle.class, name = "ELECTRIC_VEHICLE"),
@JsonSubTypes.Type(value = Vehicle.FuelVehicle.class, name = "FUEL_VEHICLE")
})
public class Vehicle {
public String type;
// standard setters and getters
public static class ElectricVehicle extends Vehicle {
String autonomy;
String chargingTime;
// standard setters and getters
}
public static class FuelVehicle extends Vehicle {
String fuelType;
String transmissionType;
// standard setters and getters
}
}
Now, let’s see how deserializing a JSON input into a Vehicle subtype works:
@Test
public void whenDeserializingPolymorphic_thenCorrect() throws JsonProcessingException {
String json = "{\"type\":\"ELECTRIC_VEHICLE\",\"autonomy\":\"500\",\"chargingTime\":\"200\"}";
Vehicle vehicle = new ObjectMapper().readerFor(Vehicle.class).readValue(json);
assertEquals(Vehicle.ElectricVehicle.class, vehicle.getClass());
}
3. Polymorphic Deserialization Using @JsonTypeInfo with Reflections for Registering Subtypes
Next, let’s explore how we can use a different approach by creating a custom annotation and using Reflections Library for scanning and registering all existing subtypes.
3.1. Reflection Introduction
Reflection is a powerful feature that allows a Java program to inspect or manipulate its structure and behavior at runtime. This is handy because we can create a custom annotation to indicate the type name of each subtype and use Reflections to identify and register them.
Our guide to the Reflections Library describes it in greater detail, as well as its use cases.
3.2. Maven Dependency
Firstly, to use Reflections, we need to add the reflections dependency:
<dependency>
<groupId>org.reflections</groupId>
<artifactId>reflections</artifactId>
<version>0.10.2</version>
</dependency>
We can find its latest version on Maven Central Repository.
3.3. Creating Custom Annotation to Indicate Type Names of Subtypes
Java annotations are a form of metadata that provide additional information about classes, methods, fields, and other program elements at compile time or runtime. They don’t directly affect the code’s logic but provide instructions or details to the compiler or runtime environment.
More information about custom annotations can be found in our article on creating a custom annotation in Java.
To indicate the type name of each Vehicle subtype, we’re going to create the following annotation, with runtime visibility and applicable to types (classes):
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface VehicleSubType {
String value();
}
Now, let’s see how we should update the existing code to specify the type for each subclass defined:
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "type", visible = true)
public class Vehicle {
public String type;
// standard setters and getters
@VehicleSubType("ELECTRIC_VEHICLE")
public static class ElectricVehicle extends Vehicle {
String autonomy;
String chargingTime;
// standard setters and getters
}
@VehicleSubType("FUEL_VEHICLE")
public static class FuelVehicle extends Vehicle {
String fuelType;
String transmissionType;
// standard setters and getters
}
}
Notice that we still need to use @JsonTypeInfo annotation on the parent class to specify the property used to store type information.
3.4. Registering Subtypes Using Reflection
Finally, we need to customize the Jackson ObjectMapper to register the annotated classes as subtypes.
We’ll start by identifying all classes annotated with our custom annotation @VehicleSubType. After that, for each class found, we can extract the value of the annotation and register the subtype with the associated type name:
private ObjectMapper getCustomObjectMapper() {
ObjectMapper objectMapper = new ObjectMapper();
Reflections reflections = new Reflections("com.baeldung.jackson.polymorphicdeserialization.reflection");
Set<Class<?>> subtypes = reflections.getTypesAnnotatedWith(VehicleSubType.class);
for (Class<?> subType : subtypes) {
VehicleSubType annotation = subType.getAnnotation(VehicleSubType.class);
if (annotation != null) {
String typeName = annotation.value();
objectMapper.registerSubtypes(new NamedType(subType, typeName));
}
}
return objectMapper;
}
Now, let’s test our code with the same input as before:
@Test
public void whenDeserializingPolymorphic_thenCorrect() throws JsonProcessingException {
String json = "{\"type\":\"ELECTRIC_VEHICLE\",\"autonomy\":\"500\",\"chargingTime\":\"200\"}";
ObjectMapper objectMapper = getCustomObjectMapper();
Vehicle vehicle = objectMapper.readValue(json, Vehicle.class);
assertEquals(Vehicle.ElectricVehicle.class, vehicle.getClass());
}
4. Differences Between the Two Approaches
The @JsonSubTypes approach offers explicit configuration by defining subtypes and their type names through annotations. This provides a centralized and clear hierarchy, ensuring compile-time safety.
Reflections-based registration allows dynamic subtype discovery at runtime. While it reduces boilerplate code, it introduces runtime overhead and lacks compile-time safety, and requires external dependencies for classpath scanning. However, this approach may be suitable when dealing with many subtypes because adding a new subtype doesn’t affect already existing code.
5. Conclusion
In this article, we’ve looked over two distinct approaches, focusing on using a custom annotation and Reflections for identifying and registering subtypes.
In conclusion, the choice between them depends on the application’s specific requirements. If the project’s subtypes are already known and stable, @JsonSubTypes provides a robust and safer option. Conversely, Reflections-based registration might be the better choice for projects demanding flexibility and runtime adaptability.
As always, the source code is available over on GitHub.