Nested DTOs in Spring Boot - Step-by-Step Execution

Concept Flow - Nested DTOs

Define Outer DTO Class

↓

Define Inner DTO Class

↓

Outer DTO has Inner DTO as a field

↓

Create Inner DTO instance

↓

Create Outer DTO instance with Inner DTO

↓

Use Outer DTO in Controller or Service

↓

Serialize/Deserialize JSON with nested structure

This flow shows how an outer DTO contains an inner DTO as a field, how instances are created, and how nested data is handled in Spring Boot.

Execution Sample

Spring Boot

public record AddressDTO(String street, String city) {}

public record UserDTO(String name, AddressDTO address) {}

AddressDTO addr = new AddressDTO("Main St", "Springfield");
UserDTO user = new UserDTO("Alice", addr);

This code defines two nested DTOs and creates instances where UserDTO contains AddressDTO.

Execution Table

Step	Action	Evaluation	Result
1	Define AddressDTO record	Class created	AddressDTO with fields street, city
2	Define UserDTO record	Class created	UserDTO with fields name, address (AddressDTO)
3	Create AddressDTO instance	new AddressDTO("Main St", "Springfield")	AddressDTO{street='Main St', city='Springfield'}
4	Create UserDTO instance	new UserDTO("Alice", AddressDTO instance)	UserDTO{name='Alice', address=AddressDTO{street='Main St', city='Springfield'}}
5	Use UserDTO in controller/service	Pass user object	Nested DTO structure ready for JSON serialization
6	Serialize UserDTO to JSON	Convert to JSON string	{"name":"Alice","address":{"street":"Main St","city":"Springfield"}}
7	Deserialize JSON to UserDTO	Parse JSON string	UserDTO{name='Alice', address=AddressDTO{street='Main St', city='Springfield'}}
8	End	All nested DTOs created and used	Execution complete

💡 All nested DTOs created and used successfully for data transfer

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
addr	null	AddressDTO{street='Main St', city='Springfield'}	AddressDTO{street='Main St', city='Springfield'}	AddressDTO{street='Main St', city='Springfield'}
user	null	null	UserDTO{name='Alice', address=AddressDTO{street='Main St', city='Springfield'}}	UserDTO{name='Alice', address=AddressDTO{street='Main St', city='Springfield'}}

Key Moments - 3 Insights

Why does UserDTO have AddressDTO as a field instead of simple strings?

UserDTO uses AddressDTO as a field to group related address data together, making the data structure clear and reusable. See execution_table step 2 and 4 where UserDTO includes AddressDTO.

How does JSON serialization handle nested DTOs?

Serialization converts nested DTOs into nested JSON objects automatically, as shown in execution_table step 6 where UserDTO with AddressDTO becomes nested JSON.

Can we create UserDTO without an AddressDTO instance?

No, because UserDTO expects an AddressDTO object for its address field. You must create AddressDTO first (step 3) before creating UserDTO (step 4).

Visual Quiz - 3 Questions

Look at the execution_table at step 4. What is the value of 'user'?

A AddressDTO{street='Main St', city='Springfield'}

B UserDTO{name='Alice', address=AddressDTO{street='Main St', city='Springfield'}}

C null

D UserDTO{name='Alice', address=null}

💡 Hint

Check the 'Result' column at step 4 in execution_table

At which step does the JSON string with nested structure appear?

A Step 3

B Step 2

C Step 6

D Step 5

💡 Hint

Look for the step mentioning JSON serialization in execution_table

If we skip creating AddressDTO before UserDTO, what happens?

A Compilation error because UserDTO requires AddressDTO

B UserDTO will have a null address field

C UserDTO will create AddressDTO automatically

D No effect, code runs fine

💡 Hint

Refer to variable_tracker and execution_table steps 3 and 4 about object creation order

Concept Snapshot

Nested DTOs in Spring Boot:
- Define inner DTO as a record/class
- Outer DTO includes inner DTO as a field
- Create inner DTO instance first
- Pass inner DTO to outer DTO constructor
- Serialization converts nested DTOs to nested JSON
- Deserialization restores nested DTO objects

Full Transcript

Nested DTOs in Spring Boot involve creating one data transfer object inside another. First, you define the inner DTO class, then the outer DTO class that has a field of the inner DTO type. You create an instance of the inner DTO with its data, then create the outer DTO instance passing the inner DTO. This nested structure allows grouping related data clearly. When sending data over the network, Spring Boot automatically converts these nested DTOs into nested JSON objects. When receiving JSON, it converts back into nested DTO instances. This process helps organize complex data simply and clearly.

Practice

1. What is the main purpose of using Nested DTOs in Spring Boot applications?

easy

A. To handle HTTP requests without controllers

B. To group related data inside other data objects for better structure

C. To replace entity classes with simpler objects

D. To improve database query performance automatically

Solution

1. Step 1: Understand DTO role

   DTOs (Data Transfer Objects) are used to carry data between processes or layers.

2. Step 2: Identify Nested DTO purpose

   Nested DTOs group related data inside other DTOs to represent complex data structures clearly.

3. Final Answer:

   To group related data inside other data objects for better structure -> Option B

4. Quick Check:

   Nested DTOs = Group related data [OK]

Hint: Nested DTOs organize data inside other objects [OK]

Common Mistakes:

• Thinking nested DTOs improve database speed
• Confusing DTOs with entities
• Assuming nested DTOs replace controllers

2. Which of the following is the correct way to declare a nested DTO class inside a parent DTO in Spring Boot?

easy

A. public class ParentDTO { private class ChildDTO { private String name; } }

B. public class ParentDTO { class ChildDTO { private String name; } }

C. public class ParentDTO { public static class ChildDTO { private String name; } }

D. public class ParentDTO { static class ChildDTO { public String name; } }

Solution

1. Step 1: Check nested class modifiers

   Static nested classes are recommended for DTOs to avoid implicit reference to outer class.

2. Step 2: Validate access modifiers

   Public static nested class with private fields and getters/setters is standard practice.

3. Final Answer:

   public class ParentDTO { public static class ChildDTO { private String name; } } -> Option C

4. Quick Check:

   Static nested class with public modifier = public class ParentDTO { public static class ChildDTO { private String name; } } [OK]

Hint: Use public static nested class for nested DTOs [OK]

Common Mistakes:

• Using non-static nested classes causing memory leaks
• Declaring nested class as private making it inaccessible
• Using public fields instead of private with getters/setters

3. Given the following nested DTO classes, what will be the output of System.out.println(order.getCustomer().getName()); if order is initialized as below?

public class OrderDTO {
  private CustomerDTO customer;
  public CustomerDTO getCustomer() { return customer; }
  public void setCustomer(CustomerDTO customer) { this.customer = customer; }
  public static class CustomerDTO {
    private String name;
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
  }
}

OrderDTO order = new OrderDTO();
OrderDTO.CustomerDTO cust = new OrderDTO.CustomerDTO();
cust.setName("Alice");
order.setCustomer(cust);

medium

A. Alice

B. null

C. Compilation error

D. Runtime NullPointerException

Solution

1. Step 1: Analyze object initialization

   The customer object is created and its name is set to "Alice" before being assigned to order.

2. Step 2: Check method calls

   Calling order.getCustomer().getName() returns the name "Alice" as set previously.

3. Final Answer:

   Alice -> Option A

4. Quick Check:

   Nested DTO getter returns set value = Alice [OK]

Hint: Set nested DTO fields before accessing getters [OK]

Common Mistakes:

• Forgetting to set nested DTO before calling getter
• Confusing null with empty string
• Assuming compilation error due to nested class

4. Identify the error in the following nested DTO code snippet:

public class UserDTO {
  private AddressDTO address;
  public static class AddressDTO {
    private String city;
    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
  }

  public AddressDTO getAddress() { return address; }
  public void setAddress(AddressDTO address) { this.address = address; }
}

UserDTO user = new UserDTO();
user.getAddress().setCity("Paris");

medium

A. Compilation error due to missing constructor

B. No error, code runs correctly

C. IllegalAccessError on accessing city field

D. NullPointerException because address is not initialized

Solution

1. Step 1: Check object initialization

   The address field in UserDTO is never initialized, so it is null by default.

2. Step 2: Analyze method call

   Calling user.getAddress().setCity("Paris") tries to call setCity on null, causing NullPointerException.

3. Final Answer:

   NullPointerException because address is not initialized -> Option D

4. Quick Check:

   Uninitialized nested DTO causes NullPointerException [OK]

Hint: Always initialize nested DTO before calling its methods [OK]

Common Mistakes:

• Assuming default constructor initializes nested DTO
• Thinking compilation error occurs
• Ignoring possibility of NullPointerException

5. You have a nested DTO structure where OrderDTO contains a list of ItemDTO objects. You want to convert this nested DTO into a flat list of item names using Java streams. Which code snippet correctly achieves this?

public class OrderDTO {
  private List<ItemDTO> items;
  public List<ItemDTO> getItems() { return items; }
  public void setItems(List<ItemDTO> items) { this.items = items; }
  public static class ItemDTO {
    private String name;
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
  }
}

OrderDTO order = ...; // initialized with items

hard

A. List<String> names = order.getItems().stream().map(OrderDTO.ItemDTO::getName).toList();

B. List<String> names = order.getItems().stream().flatMap(ItemDTO::getName).collect(Collectors.toList());

C. List<String> names = order.getItems().map(ItemDTO::getName).collect(Collectors.toList());

D. List<String> names = order.getItems().stream().map(item -> item.name).collect(Collectors.toList());

Solution

1. Step 1: Understand stream mapping

   To get a list of names, map each ItemDTO to its name using map(OrderDTO.ItemDTO::getName).

2. Step 2: Collect results

   Use toList() (Java 16+) or collect(Collectors.toList()) to gather results into a list.

3. Final Answer:

   List<String> names = order.getItems().stream().map(OrderDTO.ItemDTO::getName).toList(); -> Option A

4. Quick Check:

   Stream map + toList() = List<String> names = order.getItems().stream().map(OrderDTO.ItemDTO::getName).toList(); [OK]

Hint: Use stream().map(...).toList() to extract nested DTO fields [OK]

Common Mistakes:

• Using flatMap instead of map for simple field extraction
• Calling map on List directly without stream()
• Accessing private fields without getter