JSON serialization with Jackson in Spring Boot - Mini Project: Build & Apply

JSON serialization with Jackson

📖 Scenario: You are building a simple Spring Boot application that sends user information as JSON data over the web.Jackson is the tool that converts your Java objects into JSON format automatically.

🎯 Goal: Create a Java class representing a user, configure Jackson to serialize it, and produce JSON output with selected fields.

📋 What You'll Learn

Create a Java class called User with fields id, name, and email

Add a configuration variable to control if the email field is included in JSON

Use Jackson annotations to include or exclude the email field based on the configuration

Create a Spring Boot REST controller that returns a User object as JSON

💡 Why This Matters

🌍 Real World

APIs often send data as JSON. Jackson helps convert Java objects to JSON easily.

💼 Career

Understanding JSON serialization with Jackson is essential for backend developers working with Spring Boot APIs.

1

Create the User class with fields

Create a Java class called User with private fields int id, String name, and String email. Add a constructor that takes all three fields and getters for each field.

Spring Boot

public class User {
    // Your code here
}

Hint

Define private fields and create a constructor and getters for each field.

2

Add a configuration variable to control email inclusion

Add a public static boolean variable called includeEmail in the User class and set it to true.

Spring Boot

public class User {
    private int id;
    private String name;
    private String email;

    public static boolean includeEmail = true;

    // Your code here
}

Hint

Add a static boolean variable named includeEmail and set it to true.

3

Use Jackson annotation to conditionally include email

Add the Jackson annotation @JsonInclude with JsonInclude.Include.NON_NULL to the getEmail() method. Modify getEmail() to return email if includeEmail is true, otherwise return null.

Spring Boot

import com.fasterxml.jackson.annotation.JsonInclude;

public class User {
    private int id;
    private String name;
    private String email;

    public static boolean includeEmail = true;

    public User(int id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    @JsonInclude(JsonInclude.Include.NON_NULL)
    public String getEmail() {
        // Your code here
    }
}

Hint

Use @JsonInclude(JsonInclude.Include.NON_NULL) on getEmail() and return email only if includeEmail is true, else return null.

4

Create a REST controller to return User as JSON

Create a Spring Boot REST controller class called UserController with a method getUser() mapped to /user that returns a new User object with id=1, name="Alice", and email="[e-mail]".

Spring Boot

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    // Your code here
}

Hint

Create a class annotated with @RestController. Add a method getUser() with @GetMapping("/user") that returns a new User object.

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