1. Introduction
Jackson offers a bunch of annotations to cater to various customization needs during serialization and deserialization. One such annotation is @JsonRootName. It is used to customize the name of the root element when wrapping the main object. Essentially, when you want to wrap your object inside a single JSON root name during serialization, @JsonRootName will come in handy.
2. Example Steps
1. Create a User class annotated with @JsonRootName to specify a custom root name.
2. Enable SerializationFeature.WRAP_ROOT_VALUE in the ObjectMapper to ensure the root name is included during serialization.
3. Serialize an instance of the User class and observe the output.
3. Java Jackson @JsonRootName Example
import com.fasterxml.jackson.annotation.JsonRootName;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
public class JacksonJsonRootNameExample {
public static void main(String[] args) throws Exception {
// Initialize ObjectMapper
ObjectMapper mapper = new ObjectMapper();
// Enable the WRAP_ROOT_VALUE feature
mapper.enable(SerializationFeature.WRAP_ROOT_VALUE);
// Create a User instance
User user = new User(1, "John Doe");
// Serialize the User instance
String serializedUser = mapper.writeValueAsString(user);
// Print the serialized user
System.out.println(serializedUser);
}
@JsonRootName(value = "userDetail")
static class User {
private int id;
private String name;
public User(int id, String name) {
this.id = id;
this.name = name;
}
// Standard getters and setters omitted for brevity
}
}
Output:
{"userDetail":{"id":1,"name":"John Doe"}}
4. Step By Step Explanation
The @JsonRootName annotation is used to specify a custom root name for the serialized JSON output. However, this annotation alone isn't sufficient. To actually wrap the serialized object with the root name, we need to enable the SerializationFeature.WRAP_ROOT_VALUE feature in our ObjectMapper.
In our example, the User class is annotated with @JsonRootName(value = "userDetail"). This means, when an instance of the User class is serialized, it will be wrapped inside a "userDetail" root element. The result of serializing a user with ID "1" and name "John Doe" gives the JSON {"userDetail":{"id":1,"name":"John Doe"}}.