Request DTO for input in Spring Boot - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a Request DTO in Spring Boot?

A Request DTO (Data Transfer Object) is a simple Java class used to carry data from the client to the server in a structured way. It helps separate input data from the internal model.

beginner

Why use a Request DTO instead of directly using entity classes?

Using a Request DTO keeps input data separate from database entities. This improves security, validation, and flexibility by controlling exactly what data the client can send.

beginner

How do you define a simple Request DTO class in Spring Boot?

Create a plain Java class with private fields, public getters and setters, and optionally validation annotations like @NotNull. This class represents the expected input structure.

beginner

What annotation is commonly used in Spring Boot controller methods to bind a Request DTO?

The @RequestBody annotation is used to tell Spring Boot to convert the incoming JSON request body into the Request DTO object.

intermediate

How can you validate a Request DTO automatically in Spring Boot?

Add validation annotations (like @NotNull, @Size) to the DTO fields and use @Valid on the controller method parameter. Spring Boot will check input and return errors if invalid.

What does a Request DTO represent in Spring Boot?

A Data sent from client to server

B Database entity

C Server response data

D Configuration settings

A Request DTO carries data from the client to the server.

Which annotation binds JSON input to a Request DTO in a controller?

A @RequestBody

B @Autowired

C @ResponseBody

D @Entity

@RequestBody tells Spring Boot to convert JSON input into the DTO.

Why should you avoid using entity classes directly as input objects?

A They are too small

B They lack getters and setters

C They expose internal data and reduce security

D They cannot be serialized

Using entities directly can expose internal data and cause security risks.

Which annotation is used to trigger validation on a Request DTO parameter?

A @Autowired

B @Valid

C @RequestParam

D @NotNull

@Valid triggers validation of the DTO fields based on annotations.

What happens if a Request DTO fails validation in Spring Boot?

A The server accepts the data anyway

B The server ignores the errors

C The server crashes

D The server returns a 400 Bad Request with error details

Spring Boot returns a 400 error with validation messages if input is invalid.

Explain what a Request DTO is and why it is useful in Spring Boot applications.

Think about how data travels from client to server and how to keep it safe.

Describe how to create and use a Request DTO in a Spring Boot controller method.

Focus on the steps from defining the class to receiving input in the controller.

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