Java: Jackson: JSON serialization/deserialization?

Jackson — a library for converting Java objects to JSON and back. Standard in Spring Boot (default).

Simple analogy: Jackson is like a skilled translator at the United Nations. It sits between two parties who speak different languages — Java objects and JSON strings — and translates between them flawlessly. When you need to send a Java object to a client (JavaScript, mobile app, another service), Jackson "translates" it into JSON. When you receive JSON from an API call, Jackson "translates" it back into a Java object you can work with. Without this translator, you would have to manually parse every field — imagine writing a hundred lines of code to read each JSON key and assign it to the right field.

Why it matters: Almost every modern application communicates via REST APIs using JSON. Jackson is the bridge that makes this communication seamless. Spring Boot uses Jackson by default — when you annotate a class with @RestController and return an object, Spring automatically calls Jackson to serialize it to JSON. Understanding Jackson means understanding how data flows through your application.

Basic usage:

1ObjectMapper mapper = new ObjectMapper();
2
3// Java → JSON
4User user = new User(1L, "Alice", "alice@test.com");
5String json = mapper.writeValueAsString(user);
6// {"id":1,"name":"Alice","email":"alice@test.com"}
7
8// JSON → Java
9User parsed = mapper.readValue(json, User.class);
10
11// Write to a file
12mapper.writeValue(new File("user.json"), user);
13
14// Read from a file
15User fromFile = mapper.readValue(new File("user.json"), User.class);
16
17// JSON to a List
18List<User> users = mapper.readValue(
19    "[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]",
20    new TypeReference<List<User>>() {}
21);

Jackson Annotations:

1public class User {
2    @JsonProperty("user_id")           // Field name in JSON
3    private Long id;
4
5    private String name;
6
7    @JsonIgnore                        // Do not include in JSON
8    private String password;
9
10    @JsonFormat(pattern = "dd.MM.yyyy") // Date format
11    private LocalDate birthday;
12
13    @JsonInclude(JsonInclude.Include.NON_NULL)  // Do not include null
14    private String nickname;
15
16    @JsonAlias({"user_name", "uname"})  // Accept different names
17    public void setName(String name) { this.name = name; }
18
19    @JsonGetter("full_identity")       // Custom getter name in JSON
20    public String getFullIdentity() {
21        return id + " - " + name;
22    }
23
24    @JsonSetter("uid")                 // Accept different name for setter
25    public void setId(Long id) { this.id = id; }
26}

Handling polymorphism:

1@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
2@JsonSubTypes({
3    @JsonSubTypes.Type(value = Cat.class, name = "cat"),
4    @JsonSubTypes.Type(value = Dog.class, name = "dog")
5})
6public abstract class Animal {
7    private String name;
8}
9
10// JSON: {"type":"cat","name":"Whiskers","indoor":true}
11Animal animal = mapper.readValue(json, Animal.class); // Returns Cat instance

Custom deserializer:

1public class MoneyDeserializer extends JsonDeserializer<Money> {
2    @Override
3    public Money deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
4        String value = p.getText();  // "100.50 USD"
5        String[] parts = value.split(" ");
6        return new Money(new BigDecimal(parts[0]), Currency.getInstance(parts[1]));
7    }
8}
9
10@JsonDeserialize(using = MoneyDeserializer.class)
11private Money amount;

Common mistakes:

• Forgetting @JsonIgnore on sensitive fields — passwords or tokens leak into API responses.
• Circular references — User has a List<Order>, each Order references User. Jackson throws StackOverflowError. Fix with @JsonManagedReference / @JsonBackReference or @JsonIgnoreProperties("orders").
• Mismatched date formats — server sends "2024-01-15" but @JsonFormat expects "dd.MM.yyyy". Always align format strings.
• Not using TypeReference for generics — mapper.readValue(json, List.class) loses type info and returns List<LinkedHashMap> instead of List<User>.

Performance considerations:

• Reuse ObjectMapper — it is thread-safe and expensive to create. Never instantiate one per request.
• Pre-compile modules for complex schemas with ObjectMapper.registerModule().
• Avoid readValue on large streams — use JsonParser for streaming processing of huge JSON files.

Useful Spring Boot features:

• spring.jackson.date-format=dd.MM.yyyy — global date format.
• spring.jackson.serialization.write-dates-as-timestamps=false.
• spring.jackson.default-property-inclusion=non_null.
• spring.jackson.serialization.fail-on-empty-beans=false — avoid errors for empty DTOs.