Why DTOs matter in Spring Boot - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use DTOs in Spring Boot applications?

In a Spring Boot app, what is the main reason to use Data Transfer Objects (DTOs)?

A To separate the internal data model from what is exposed to clients, improving security and flexibility.

B To replace the database entities entirely and avoid using JPA repositories.

C To automatically generate database tables without writing SQL scripts.

D To speed up the application by caching all data in memory.

💡 Hint

Think about how you protect your private information when sharing only what is needed.

DTOs act like a filter between your database entities and the outside world. They help keep internal details private and allow you to change your database without breaking clients.

❓ component_behavior

intermediate

What happens if you return entities directly from a Spring Boot REST controller?

Consider a Spring Boot REST controller that returns JPA entities directly as JSON. What is a likely problem?

A The application will run faster because no extra mapping is needed.

B The database schema will automatically update to match the JSON structure.

C The REST controller will cache the entities and never refresh data.

D The JSON may expose sensitive fields and cause infinite recursion errors due to bidirectional relationships.

💡 Hint

Think about what happens when you share your full address book with everyone, including private notes.

Returning entities directly can expose sensitive data and cause serialization problems like infinite loops when entities reference each other.

❓ state_output

advanced

What is the output of this Spring Boot controller method using a DTO?

Given the following code snippet, what JSON will the client receive?

Spring Boot

public record UserEntity(Long id, String username, String password) {}

public record UserDTO(Long id, String username) {}

@GetMapping("/user/{id}")
public UserDTO getUser(@PathVariable Long id) {
    UserEntity user = userService.findById(id);
    return new UserDTO(user.id(), user.username());
}

A {"id":1,"username":"alice","password":"secret"}

B {"id":1,"username":"alice"}

C {"username":"alice"}

D {"id":1}

💡 Hint

Look at which fields the DTO includes compared to the entity.

The DTO only includes id and username, so the password is not sent to the client.

📝 Syntax

advanced

Which code snippet correctly maps an entity to a DTO in Spring Boot?

Choose the correct Java code that converts a UserEntity to a UserDTO.

A UserDTO dto = new UserDTO(userEntity.getId());

B UserDTO dto = new UserDTO(userEntity.id, userEntity.username, userEntity.password);

C UserDTO dto = new UserDTO(userEntity.getId(), userEntity.getUsername());

D UserDTO dto = new UserDTO(userEntity.getUsername());

💡 Hint

Remember the DTO only has id and username fields.

Option C correctly passes the two required fields. Options B, C, and D either pass wrong number of arguments or include password which DTO does not have.

🔧 Debug

expert

Why does this Spring Boot app throw a StackOverflowError when returning entities directly?

Given two JPA entities User and Address with bidirectional @OneToMany and @ManyToOne relationships, returning User directly from a REST controller causes a StackOverflowError. Why?

A Because the JSON serializer tries to serialize User, then Address, then User again endlessly due to circular references.

B Because the database connection is lost during serialization.

C Because the REST controller method is missing @ResponseBody annotation.

D Because the User entity has no default constructor.

💡 Hint

Think about what happens when you look in a mirror facing another mirror.

The circular references between User and Address cause the JSON serializer to recurse infinitely, leading to StackOverflowError.