JSON serialization with Jackson in Spring Boot - Step-by-Step Execution

Concept Flow - JSON serialization with Jackson

Create Java Object

↓

Call ObjectMapper.writeValueAsString()

↓

Jackson inspects Object fields

↓

Convert fields to JSON key-value pairs

↓

Build JSON string

↓

Return JSON string

This flow shows how Jackson converts a Java object into a JSON string step-by-step.

Execution Sample

Spring Boot

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

This code creates a User object and uses Jackson's ObjectMapper to convert it to a JSON string.

Execution Table

Step	Action	Input	Output	Notes
1	Create User object	name="Alice", age=30	User{name='Alice', age=30}	Java object created with fields
2	Call writeValueAsString	User object	Jackson inspects fields	Jackson reads fields via getters or reflection
3	Serialize fields	name='Alice', age=30	{"name":"Alice","age":30}	Fields converted to JSON key-value pairs
4	Return JSON string	JSON string	{"name":"Alice","age":30}	JSON string ready for output
5	Print JSON	JSON string	{"name":"Alice","age":30}	Output shown on console
6	End	N/A	N/A	Serialization complete

💡 Serialization ends after JSON string is returned and printed.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
user	null	User{name='Alice', age=30}	User{name='Alice', age=30}	User{name='Alice', age=30}	User{name='Alice', age=30}
json	null	null	null	{"name":"Alice","age":30}	{"name":"Alice","age":30}

Key Moments - 3 Insights

Why does Jackson need getters or reflection to access object fields?

Jackson uses getters or reflection to read private fields because direct field access is often restricted. This is shown in step 2 where Jackson inspects the object.

What happens if a field is null during serialization?

By default, Jackson includes null fields as key with null value in JSON. This behavior can be customized with annotations or configuration, but the basic flow still serializes all fields.

Why is the output a string and not a Java object?

writeValueAsString returns a JSON-formatted string representing the object, which can be sent over networks or saved. This is the final output in step 4.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'json' after step 3?

A User{name='Alice', age=30}

B {"name":"Alice","age":30}

C null

D ObjectMapper instance

💡 Hint

Check the 'Output' column at step 3 in the execution table.

At which step does Jackson inspect the object fields?

A Step 1

B Step 4

C Step 2

D Step 5

💡 Hint

Look for the step where Jackson reads fields via getters or reflection.

If the User object had a new field 'email' added, how would the JSON string change?

A It would include "email" key with its value in the JSON string

B The JSON string would remain the same

C Serialization would fail

D The JSON string would exclude all other fields

💡 Hint

Jackson serializes all fields by default, so new fields appear in the JSON output.

Concept Snapshot

Jackson JSON Serialization:
- Use ObjectMapper.writeValueAsString(object)
- Converts Java object fields to JSON key-value pairs
- Uses getters or reflection to access fields
- Returns JSON as a string
- Can customize output with annotations

Full Transcript

This visual execution trace shows how Jackson serializes a Java object to JSON. First, a User object is created with name and age fields. Then, the ObjectMapper's writeValueAsString method is called with this object. Jackson inspects the object's fields using getters or reflection. It converts each field into a JSON key-value pair and builds a JSON string. Finally, the JSON string is returned and printed. Variables 'user' and 'json' track the object and resulting string. Key moments clarify why Jackson needs getters, how null fields are handled, and why the output is a string. The quiz tests understanding of the serialization steps and output changes when fields are added.

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