@Valid annotation on request body in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when @Valid fails on a request body?

Consider a Spring Boot controller method that uses @Valid on a request body object. What is the default behavior when the validation fails?

Spring Boot

public ResponseEntity<String> createUser(@Valid @RequestBody User user) {
    return ResponseEntity.ok("User created");
}

A The method returns HTTP 400 Bad Request with validation error details.

B The method proceeds normally and returns HTTP 200 OK.

C The method throws a NullPointerException.

D The method returns HTTP 500 Internal Server Error.

💡 Hint

Think about how Spring Boot handles validation exceptions by default.

When @Valid fails, Spring Boot automatically returns a 400 Bad Request response with details about the validation errors.

📝 Syntax

intermediate

Which code snippet correctly applies @Valid on a request body?

Select the code snippet that correctly uses @Valid to validate a request body in a Spring Boot controller.

A public ResponseEntity<String> add(@RequestBody User user) { return ResponseEntity.ok("Added"); }

B public ResponseEntity<String> add(@RequestBody @Valid User user) { return ResponseEntity.ok("Added"); }

C public ResponseEntity<String> add(@Valid User user) { return ResponseEntity.ok("Added"); }

D public ResponseEntity<String> add(User user) { return ResponseEntity.ok("Added"); }

💡 Hint

Remember that @Valid must be combined with @RequestBody to validate JSON input.

@Valid must be placed on the parameter annotated with @RequestBody to trigger validation of the incoming JSON.

🔧 Debug

advanced

Why does validation not trigger with @Valid on a request body?

Given this controller method, validation does not trigger even though @Valid is present. What is the most likely cause? public ResponseEntity updateUser(@RequestBody User user) { return ResponseEntity.ok("Updated"); }

Spring Boot

public ResponseEntity<String> updateUser(@RequestBody User user) {
    return ResponseEntity.ok("Updated");
}

A The method return type must be void for validation to work.

B The User class does not have any validation annotations.

C The controller method is missing @PostMapping annotation.

D The @Valid annotation is missing on the parameter.

💡 Hint

Check if the parameter is annotated with @Valid.

Validation only triggers if @Valid is present on the @RequestBody parameter.

❓ state_output

advanced

What is the response body when validation fails on a @Valid request body?

If a POST request sends invalid data to a Spring Boot controller method with @Valid on the request body, what does the response body contain by default?

A A JSON object listing field errors and messages.

B An empty response body with status 400.

C A plain text message 'Validation failed'.

D The original invalid JSON sent by the client.

💡 Hint

Think about how Spring Boot formats validation error responses.

Spring Boot returns a JSON response with details about each field that failed validation.

🧠 Conceptual

expert

How to customize validation error responses for @Valid request bodies?

Which approach allows customizing the error response sent when @Valid validation fails on a request body in Spring Boot?

A Add a @ResponseStatus annotation on the controller method.

B Override the toString() method of the request body class.

C Implement a @ControllerAdvice class with an @ExceptionHandler for MethodArgumentNotValidException.

D Use @JsonIgnore on all fields in the request body class.

💡 Hint

Think about global exception handling in Spring Boot.

Using @ControllerAdvice with @ExceptionHandler for MethodArgumentNotValidException lets you customize validation error responses.

Practice

1. What is the main purpose of using the @Valid annotation on a @RequestBody parameter in a Spring Boot controller?

easy

A. To automatically check if the incoming request data meets the validation rules defined in the data class.

B. To convert the request body into a JSON string.

C. To log the request body content for debugging.

D. To cache the request body for faster access.

Solution

1. Step 1: Understand the role of @Valid

   The @Valid annotation triggers validation of the request body object based on constraints defined in its class.

2. Step 2: Connect validation to request handling

   When placed before @RequestBody, it ensures the data is checked before the controller method uses it.

3. Final Answer:

   To automatically check if the incoming request data meets the validation rules defined in the data class. -> Option A

4. Quick Check:

   @Valid validates input data [OK]

Hint: Remember: @Valid checks data correctness before method runs [OK]

Common Mistakes:

• Thinking @Valid converts or logs data
• Placing @Valid after @RequestBody
• Assuming @Valid caches data

2. Which of the following is the correct way to use @Valid in a Spring Boot controller method parameter?

easy

A. public ResponseEntity create(@RequestBody User user @Valid) { ... }

B. public ResponseEntity create(@Valid User user @RequestBody) { ... }

C. public ResponseEntity create(@Valid @RequestBody User user) { ... }

D. public ResponseEntity create(User user @Valid @RequestBody) { ... }

Solution

1. Step 1: Recall annotation order for parameters

   In Spring Boot, @Valid must come before @RequestBody on the same parameter.

2. Step 2: Check each option's syntax

   Only public ResponseEntity create(@Valid @RequestBody User user) { ... } correctly places @Valid before @RequestBody on the parameter.

3. Final Answer:

   public ResponseEntity create(@Valid @RequestBody User user) { ... } -> Option C

4. Quick Check:

   Correct annotation order = public ResponseEntity create(@Valid @RequestBody User user) { ... } [OK]

Hint: Put @Valid before @RequestBody on the same parameter [OK]

Common Mistakes:

• Placing @Valid after @RequestBody
• Separating annotations incorrectly
• Using @Valid without @RequestBody

3. Given the following controller method and data class, what happens when a POST request sends an empty JSON object {}?

public record User(@NotBlank String name, @Min(18) int age) {}

@PostMapping("/users")
public ResponseEntity<String> addUser(@Valid @RequestBody User user) {
    return ResponseEntity.ok("User added");
}

medium

A. The request succeeds but 'age' defaults to 0.

B. The request succeeds and returns 'User added'.

C. The request fails because @Valid is ignored on records.

D. The request fails validation because 'name' is blank and 'age' is missing.

Solution

1. Step 1: Analyze validation constraints on User record

   @NotBlank requires 'name' to be non-empty; @Min(18) requires 'age' to be at least 18.

2. Step 2: Consider empty JSON input effects

   Empty JSON means 'name' and 'age' are missing, so validation fails for both fields.

3. Final Answer:

   The request fails validation because 'name' is blank and 'age' is missing. -> Option D

4. Quick Check:

   Missing required fields cause validation failure [OK]

Hint: Empty JSON fails @NotBlank and @Min validations [OK]

Common Mistakes:

• Assuming missing fields pass validation
• Thinking @Valid ignores records
• Assuming default values apply automatically

4. You have this controller method:

@PostMapping("/register")
public ResponseEntity<String> registerUser(@RequestBody @Valid User user) {
    return ResponseEntity.ok("Registered");
}

But when you send invalid data, no validation errors occur and the method runs normally. What is the most likely cause?

medium

A. Missing @Validated annotation on the controller class or configuration.

B. The User class does not have any validation annotations.

C. The @Valid annotation is placed after @RequestBody.

D. Spring Boot does not support validation on request bodies.

Solution

1. Step 1: Check if User class has validation rules

   If the User class lacks validation annotations like @NotNull, @NotBlank, etc., @Valid has nothing to check.

2. Step 2: Understand validation behavior

   Without constraints, validation passes silently, so the method runs normally even with invalid data.

3. Final Answer:

   The User class does not have any validation annotations. -> Option B

4. Quick Check:

   No constraints = no validation errors [OK]

Hint: Validation needs annotations in the data class [OK]

Common Mistakes:

• Assuming @Validated is always required
• Thinking annotation order causes no validation
• Believing Spring Boot disables validation by default

5. You want to create a Spring Boot API that accepts a JSON request body for a Product with fields name (required, not blank) and price (required, positive number). Which of the following code snippets correctly applies @Valid and validation annotations to ensure invalid data is rejected automatically?

hard

A. public record Product(@NotBlank String name, @Positive double price) {}

@PostMapping("/products")
public ResponseEntity<String> addProduct(@Valid @RequestBody Product product) {
return ResponseEntity.ok("Product added");
}

B. public class Product {
public String name;
public double price;
}

@PostMapping("/products")
public ResponseEntity<String> addProduct(@RequestBody Product product) {
return ResponseEntity.ok("Product added");
}

C. public record Product(String name, double price) {}

@PostMapping("/products")
public ResponseEntity<String> addProduct(@RequestBody @Valid Product product) {
return ResponseEntity.ok("Product added");
}

D. public record Product(@NotNull String name, @Min(1) double price) {}

@PostMapping("/products")
public ResponseEntity<String> addProduct(@RequestBody Product product) {
return ResponseEntity.ok("Product added");
}

Solution

1. Step 1: Identify correct validation annotations

   @NotBlank ensures 'name' is not empty; @Positive ensures 'price' is greater than zero.

2. Step 2: Check usage of @Valid and @RequestBody

   public record Product(@NotBlank String name, @Positive double price) {} @PostMapping("/products") public ResponseEntity<String> addProduct(@Valid @RequestBody Product product) { return ResponseEntity.ok("Product added"); } correctly places @Valid before @RequestBody in the controller method parameter.

3. Step 3: Verify other options

   public class Product { public String name; public double price; } @PostMapping("/products") public ResponseEntity<String> addProduct(@RequestBody Product product) { return ResponseEntity.ok("Product added"); } lacks validation annotations and @Valid. public record Product(String name, double price) {} @PostMapping("/products") public ResponseEntity<String> addProduct(@RequestBody @Valid Product product) { return ResponseEntity.ok("Product added"); } misses validation annotations. public record Product(@NotNull String name, @Min(1) double price) {} @PostMapping("/products") public ResponseEntity<String> addProduct(@RequestBody Product product) { return ResponseEntity.ok("Product added"); } uses @Min(1) on a double (should use @Positive) and misses @Valid.

4. Final Answer:

   public record Product(@NotBlank String name, @Positive double price) {} @PostMapping("/products") public ResponseEntity<String> addProduct(@Valid @RequestBody Product product) { return ResponseEntity.ok("Product added"); } -> Option A

5. Quick Check:

   Use @Valid + proper annotations = public record Product(@NotBlank String name, @Positive double price) {} @PostMapping("/products") public ResponseEntity<String> addProduct(@Valid @RequestBody Product product) { return ResponseEntity.ok("Product added"); } [OK]

Hint: Use @Valid + @NotBlank and @Positive for required fields [OK]

Common Mistakes:

• Omitting @Valid in controller method
• Using wrong validation annotations for types
• Not annotating fields in data class