JSON serialization with Jackson in Spring Boot - Performance & Optimization

Performance: JSON serialization with Jackson

MEDIUM IMPACT

This affects how fast JSON data is converted and sent to the client, impacting server response time and perceived page load speed.

Serializing Java objects to JSON for API responses

Spring Boot

private static final ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(largeObject);

Reusing a single ObjectMapper instance avoids repeated costly setup and speeds up serialization.

📈 Performance GainReduces blocking time by up to 80% per request

Serializing Java objects to JSON for API responses

Spring Boot

ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(largeObject);

Creating a new ObjectMapper instance for every serialization is expensive and slows down response time.

📉 Performance CostBlocks rendering for 10-50ms per request depending on object size

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
New ObjectMapper per request	N/A	N/A	Blocks server response 10-50ms	[X] Bad
Reuse ObjectMapper singleton	N/A	N/A	Minimal server blocking	[OK] Good
Serialize all fields including sensitive	N/A	N/A	Increases JSON size by 5-20kb	[X] Bad
Exclude unnecessary fields with @JsonIgnore	N/A	N/A	Reduces JSON size, faster transfer	[OK] Good
Serialize large collections fully in memory	N/A	N/A	Blocks server 100+ms on large data	[X] Bad
Stream serialization with JsonGenerator	N/A	N/A	Reduces blocking by 50%+	[OK] Good

Rendering Pipeline

Jackson serialization runs on the server before the browser receives data. Slow serialization delays the server response, increasing Largest Contentful Paint (LCP) time. Efficient serialization reduces server CPU load and response size, improving network transfer and browser rendering speed.

→Server Processing

→Network Transfer

→Browser Rendering

⚠️ BottleneckServer Processing (Serialization CPU and memory use)

Core Web Vital Affected

LCP

This affects how fast JSON data is converted and sent to the client, impacting server response time and perceived page load speed.

Optimization Tips

1Reuse ObjectMapper instances instead of creating new ones per request.

2Exclude unnecessary or sensitive fields to reduce JSON size.

3Use streaming serialization for large data sets to reduce memory and CPU load.

Performance Quiz - 3 Questions

What is a common performance issue when creating a new ObjectMapper instance for every JSON serialization?

A It improves browser rendering speed.

B It reduces JSON size automatically.

C It causes repeated expensive setup, slowing server response.

D It caches serialized data for reuse.

DevTools: Network

How to check: Open DevTools, go to Network tab, reload API request, inspect response size and timing.

What to look for: Look for large JSON payload sizes and long server response times indicating slow serialization.

Practice

1. What is the primary purpose of Jackson in a Spring Boot application?

easy

A. To convert Java objects to JSON and vice versa

B. To manage database connections

C. To handle HTTP requests

D. To style HTML pages

Solution

1. Step 1: Understand Jackson's role

   Jackson is a library used to convert Java objects into JSON format and back.

2. Step 2: Compare options with Jackson's function

   Only To convert Java objects to JSON and vice versa describes this conversion role; others relate to different tasks.

3. Final Answer:

   To convert Java objects to JSON and vice versa -> Option A

4. Quick Check:

   Jackson = Java-JSON conversion [OK]

Hint: Jackson is for JSON conversion, not database or UI tasks [OK]

Common Mistakes:

• Confusing Jackson with database or HTTP handling
• Thinking Jackson styles HTML
• Assuming Jackson manages server requests

2. Which of the following is the correct way to serialize a Java object to a JSON string using Jackson's ObjectMapper?

easy

A. objectMapper.readValue(object, String.class);

B. objectMapper.writeValueAsString(object);

C. objectMapper.toJson(object);

D. objectMapper.serialize(object);

Solution

1. Step 1: Identify the serialization method in ObjectMapper

   The method to convert an object to JSON string is writeValueAsString.

2. Step 2: Check other options for correctness

   readValue is for deserialization, toJson and serialize are not valid ObjectMapper methods.

3. Final Answer:

   objectMapper.writeValueAsString(object); -> Option B

4. Quick Check:

   Serialize with writeValueAsString() [OK]

Hint: Use writeValueAsString() to convert object to JSON string [OK]

Common Mistakes:

• Using readValue() instead of writeValueAsString()
• Assuming toJson() or serialize() exist in ObjectMapper
• Mixing serialization and deserialization methods

3. Given the following code snippet, what will be the output?

ObjectMapper mapper = new ObjectMapper();
User user = new User("Alice", 30);
String json = mapper.writeValueAsString(user);
System.out.println(json);

Assuming User class has fields 'name' and 'age' with getters.

medium

A. {"Alice":30}

B. {"userName":"Alice","userAge":30}

C. {"name":"Alice","age":30}

D. Error: Cannot serialize User object

Solution

1. Step 1: Understand default serialization of User object

   Jackson serializes fields with their names and values, so 'name' and 'age' become JSON keys and values.

2. Step 2: Match output with expected JSON format

   {"name":"Alice","age":30} matches the expected JSON string with keys 'name' and 'age' and their values.

3. Final Answer:

   {"name":"Alice","age":30} -> Option C

4. Quick Check:

   Default serialization = field names as keys [OK]

Hint: Default JSON keys match Java field names with getters [OK]

Common Mistakes:

• Expecting custom key names without annotations
• Assuming serialization fails without extra config
• Confusing field names with variable names

4. What is wrong with this code snippet that tries to pretty-print JSON?

ObjectMapper mapper = new ObjectMapper();
mapper.enable(SerializationFeature.PRETTY_PRINT);
String json = mapper.writeValueAsString(user);

medium

A. SerializationFeature.PRETTY_PRINT does not exist; should use INDENT_OUTPUT

B. writeValueAsString cannot produce pretty JSON

C. ObjectMapper must be configured with a custom serializer

D. Pretty print requires calling writeValue() instead

Solution

1. Step 1: Check correct SerializationFeature for pretty print

   The correct feature name is INDENT_OUTPUT, not PRETTY_PRINT.

2. Step 2: Verify usage of writeValueAsString

   writeValueAsString supports pretty printing if INDENT_OUTPUT is enabled.

3. Final Answer:

   SerializationFeature.PRETTY_PRINT does not exist; should use INDENT_OUTPUT -> Option A

4. Quick Check:

   Use INDENT_OUTPUT for pretty print [OK]

Hint: Use SerializationFeature.INDENT_OUTPUT for pretty JSON [OK]

Common Mistakes:

• Using wrong feature name PRETTY_PRINT
• Thinking writeValueAsString can't pretty print
• Believing custom serializers are always needed

5. You want to serialize a Java object to JSON but exclude null fields from the output. Which Jackson configuration achieves this?

hard

A. mapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);

B. mapper.disable(SerializationFeature.WRITE_NULLS);

C. mapper.enable(SerializationFeature.EXCLUDE_NULLS);

D. mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

Solution

1. Step 1: Identify correct method to exclude null fields

   Jackson uses setSerializationInclusion with JsonInclude.Include.NON_NULL to skip nulls.

2. Step 2: Check other options for validity

   WRITE_NULLS and EXCLUDE_NULLS are not valid features; ALWAYS includes all fields.

3. Final Answer:

   mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); -> Option D

4. Quick Check:

   Exclude nulls with NON_NULL inclusion [OK]

Hint: Use NON_NULL inclusion to skip null fields [OK]

Common Mistakes:

• Using non-existent SerializationFeature flags
• Confusing ALWAYS with excluding nulls
• Trying to disable null writing with wrong methods