Request DTO for input in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when a Spring Boot controller receives this Request DTO?

Consider this Spring Boot Request DTO and controller method:

public record UserRequest(String name, int age) {}

@PostMapping("/user")
public ResponseEntity createUser(@RequestBody UserRequest request) {
    return ResponseEntity.ok("User " + request.name() + " is " + request.age() + " years old.");
}

If the JSON {"name":"Alice","age":30} is sent, what will the response body be?

A HTTP 400 Bad Request error

B "User null is 0 years old."

C "User Alice is 30 years old."

D "User Alice is null years old."

💡 Hint

Records automatically map JSON fields to constructor parameters by name.

The JSON fields match the record components exactly, so Spring Boot deserializes correctly. The response concatenates the values properly.

📝 Syntax

intermediate

Which Request DTO declaration is syntactically correct in Spring Boot using Java records?

Choose the correct Java record declaration for a Request DTO with fields email (String) and subscribed (boolean):

A public record SubscriptionRequest(String email, Boolean subscribed) {}

B public record SubscriptionRequest(String email; boolean subscribed) {}

C public record SubscriptionRequest { String email; boolean subscribed; }

D public record SubscriptionRequest(String email, boolean subscribed) {}

💡 Hint

Records use parentheses with comma-separated components.

Option D uses the correct syntax for Java records. Option D uses semicolon instead of comma. Option D is not a record syntax. Option D uses boxed Boolean which is valid but not the exact requested type.

🔧 Debug

advanced

Why does this Spring Boot controller fail to bind the JSON to the Request DTO?

Given this Request DTO and controller method:

public record ProductRequest(String productName, int quantity) {}

@PostMapping("/product")
public ResponseEntity addProduct(ProductRequest request) {
    return ResponseEntity.ok("Added " + request.productName() + ", qty: " + request.quantity());
}

When sending JSON {"productName":"Pen","quantity":10}, the server returns HTTP 400. Why?

A Missing @RequestBody annotation on the method parameter causes binding failure.

B Record fields must be public for binding to work.

C JSON keys do not match record component names.

D The controller method must return void for POST requests.

💡 Hint

Spring Boot needs an annotation to know where to get the data from.

Without @RequestBody, Spring tries to bind from form data or query parameters, not JSON body, causing HTTP 400 error.

❓ state_output

advanced

What is the value of the 'age' field after deserialization?

Given this Request DTO record and JSON input:

public record PersonRequest(String name, Integer age) {}

JSON sent: {"name":"Bob"}

What will be the value of age() in the deserialized object?

A Undefined, depends on JVM

B null

C 0

D Throws NullPointerException

💡 Hint

Consider the difference between primitive and wrapper types.

Since age is Integer (wrapper), missing JSON field results in null. If it were int (primitive), it would default to 0.

🧠 Conceptual

expert

Which statement about using Java records as Request DTOs in Spring Boot is true?

Choose the correct statement about Java records used as Request DTOs in Spring Boot:

A Records automatically provide immutable data carriers suitable for Request DTOs.

B Records require a no-argument constructor to be used as Request DTOs.

C Records cannot be used as Request DTOs because they lack setters.

D Records require explicit Jackson annotations on every field to deserialize JSON.

💡 Hint

Think about how records handle data and immutability.

Records are immutable data carriers with final fields and canonical constructors, making them ideal for Request DTOs without needing setters or no-arg constructors.

Practice

1. What is the main purpose of a Request DTO in a Spring Boot application?

easy

A. To configure the application server settings

B. To store data directly in the database

C. To handle HTTP responses sent to the client

D. To organize and validate user input separately from database models

Solution

1. Step 1: Understand what a Request DTO is

   A Request DTO (Data Transfer Object) is used to receive and organize input data from users in a clean way.

2. Step 2: Differentiate from other components

   Unlike database models, Request DTOs focus only on input validation and structure, not on storing data.

3. Final Answer:

   To organize and validate user input separately from database models -> Option D

4. Quick Check:

   Request DTO = Input organization and validation [OK]

Hint: Request DTOs separate input from database models [OK]

Common Mistakes:

• Confusing DTO with database entity
• Thinking DTO handles HTTP responses
• Assuming DTO configures server

2. Which of the following is the correct way to declare a simple Request DTO class in Spring Boot to receive a user's name and age?

easy

A. public interface UserRequest { String getName(); int getAge(); }

B. public class UserRequest { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }

C. @Entity public class UserRequest { private String name; private int age; }

D. @Controller public class UserRequest { private String name; private int age; }

Solution

1. Step 1: Identify the correct DTO structure

   A Request DTO is a simple Java class with private fields and public getters/setters to hold input data.

2. Step 2: Check annotations and class type

   It should NOT be an entity or controller; those are for database and web layers respectively.

3. Final Answer:

   Plain Java class with private fields and getters/setters -> Option B

4. Quick Check:

   DTO = Plain class with getters/setters [OK]

Hint: DTOs are plain classes, not entities or controllers [OK]

Common Mistakes:

• Using @Entity annotation on DTO
• Making DTO an interface
• Annotating DTO as @Controller

3. Given the following Request DTO and controller method, what will be the output if the JSON input is {"name":"Alice","age":30}?

public class UserRequest {
  private String name;
  private int age;
  public String getName() { return name; }
  public void setName(String name) { this.name = name; }
  public int getAge() { return age; }
  public void setAge(int age) { this.age = age; }
}

@PostMapping("/user")
public String createUser(@RequestBody UserRequest request) {
  return "User: " + request.getName() + ", Age: " + request.getAge();
}

medium

A. User: null, Age: 0

B. Compilation error due to missing annotations

C. User: Alice, Age: 30

D. Runtime error due to invalid JSON

Solution

1. Step 1: Understand JSON to DTO mapping

   The JSON keys match the DTO fields, so Spring Boot maps "name" to name and "age" to age correctly.

2. Step 2: Check controller return value

   The method returns a string combining name and age from the DTO, so it outputs "User: Alice, Age: 30".

3. Final Answer:

   User: Alice, Age: 30 -> Option C

4. Quick Check:

   Matching JSON fields produce correct output [OK]

Hint: Matching JSON keys to DTO fields maps input correctly [OK]

Common Mistakes:

• Assuming missing annotations cause errors
• Expecting null values despite matching JSON
• Confusing runtime errors with mapping

4. Identify the error in this Request DTO class that causes Spring Boot to fail binding JSON input:

public class ProductRequest {
  private String productName;
  private int quantity;
  public int getQuantity() { return quantity; }
  public void setQuantity(int quantity) { this.quantity = quantity; }
}

medium

A. Missing getter and setter for productName field

B. Quantity field should be public

C. Class must be annotated with @RequestBody

D. No default constructor defined

Solution

1. Step 1: Check field access and methods

   productName lacks getter/setter, so Spring cannot bind JSON to it properly.

2. Step 2: Validate other options

   Quantity has proper getter/setter; @RequestBody is for method parameters, not classes; default constructor is implicit.

3. Final Answer:

   Missing getter and setter for productName field -> Option A

4. Quick Check:

   DTO fields need getters/setters for binding [OK]

Hint: DTO fields need getters/setters for JSON binding [OK]

Common Mistakes:

• Thinking public fields bind without getters/setters
• Adding @RequestBody on DTO class
• Assuming default constructor must be explicit

5. You want to ensure that the email field in your Request DTO is not empty and follows a valid email format. Which annotations should you add to the email field to achieve this validation automatically in Spring Boot?

hard

A. @NotEmpty and @Email

B. @Valid and @NotNull

C. @Size(min=1) and @Pattern(regexp=".+@.+\\..+")

D. @NotBlank and @JsonProperty

Solution

1. Step 1: Identify validation annotations for non-empty and email format

   @NotEmpty ensures the field is not empty, and @Email checks for valid email format.

2. Step 2: Evaluate other options

   @Valid is for nested validation, @NotNull allows empty strings, @Size and @Pattern can work but are more complex; @JsonProperty is for JSON mapping, not validation.

3. Final Answer:

   @NotEmpty and @Email -> Option A

4. Quick Check:

   Use @NotEmpty and @Email for email validation [OK]

Hint: Use @NotEmpty and @Email for email validation [OK]

Common Mistakes:

• Using @NotNull which allows empty strings
• Confusing @Valid with validation annotations
• Using @JsonProperty for validation