Validation error responses in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when a Spring Boot controller receives invalid input?

Consider a Spring Boot REST controller method annotated with @Valid on its input DTO. What will the client receive if the input fails validation?

Spring Boot

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

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

A HTTP 500 Internal Server Error due to validation failure

B HTTP 200 OK with an empty response body

C HTTP 400 Bad Request with a JSON body listing validation errors

D HTTP 404 Not Found because the resource is missing

💡 Hint

Think about how Spring Boot handles @Valid and validation exceptions by default.

Spring Boot automatically returns HTTP 400 Bad Request with details about validation errors when @Valid fails.

📝 Syntax

intermediate

Which code snippet correctly customizes validation error responses in Spring Boot?

You want to return a custom JSON structure for validation errors. Which code snippet correctly implements this using @ControllerAdvice?

A

@ControllerAdvice
public class ValidationHandler {
  public ResponseEntity<String> handleValidation(MethodArgumentNotValidException ex) {
    return ResponseEntity.badRequest().body("Error");
  }
}

B

@ControllerAdvice
public class ValidationHandler {
  @ExceptionHandler(MethodArgumentNotValidException.class)
  public ResponseEntity<Map<String, String>> handleValidation(MethodArgumentNotValidException ex) {
    Map<String, String> errors = new HashMap<>();
    ex.getBindingResult().getFieldErrors().forEach(error ->
      errors.put(error.getField(), error.getDefaultMessage()));
    return ResponseEntity.badRequest().body(errors);
  }
}

C

@RestController
public class ValidationHandler {
  @ExceptionHandler(MethodArgumentNotValidException.class)
  public String handleValidation() {
    return "Validation failed";
  }
}

D

@ControllerAdvice
public class ValidationHandler {
  @ExceptionHandler(Exception.class)
  public ResponseEntity<String> handleAll(Exception ex) {
    return ResponseEntity.status(500).body("Server error");
  }
}

💡 Hint

Look for the method signature that catches the right exception and returns a detailed map.

Option B correctly uses @ExceptionHandler for MethodArgumentNotValidException and builds a map of field errors.

🔧 Debug

advanced

Why does this Spring Boot validation error handler not work as expected?

Given this code, why does the custom validation error handler never get called?

Spring Boot

@ControllerAdvice
public class CustomValidationHandler {
  @ExceptionHandler(BindException.class)
  public ResponseEntity<String> handleBind(BindException ex) {
    return ResponseEntity.badRequest().body("Bind error");
  }
}

@PostMapping("/submit")
public ResponseEntity<String> submit(@Valid @RequestBody UserDTO user) {
  return ResponseEntity.ok("Success");
}

A The exception thrown is MethodArgumentNotValidException, not BindException, so the handler is not triggered

B The @ControllerAdvice class is missing @RestController annotation

C The @Valid annotation should be on the controller class, not the method parameter

D The handler method must return void to work correctly

💡 Hint

Check which exception Spring Boot throws for @Valid on @RequestBody parameters.

Spring Boot throws MethodArgumentNotValidException for @Valid on @RequestBody, so the handler for BindException is never called.

❓ state_output

advanced

What is the JSON response body when a validation error occurs with this handler?

Given this handler, what JSON will the client receive if the 'email' field is empty?

Spring Boot

@ControllerAdvice
public class ValidationErrorHandler {
  @ExceptionHandler(MethodArgumentNotValidException.class)
  public ResponseEntity<Map<String, String>> handleValidationErrors(MethodArgumentNotValidException ex) {
    Map<String, String> errors = new HashMap<>();
    ex.getBindingResult().getFieldErrors().forEach(error ->
      errors.put(error.getField(), error.getDefaultMessage()));
    return ResponseEntity.badRequest().body(errors);
  }
}

// UserDTO with @NotBlank on 'email' field

A {"email":null}

B {"error":"Validation failed"}

C {"message":"Invalid input"}

D {"email":"must not be blank"}

💡 Hint

The handler builds a map with field names and their error messages.

The handler returns a JSON object with the field name as key and the validation message as value.

🧠 Conceptual

expert

Which statement about Spring Boot validation error handling is true?

Select the correct statement about how Spring Boot handles validation errors by default and how to customize them.

A Spring Boot automatically returns HTTP 400 with a default error body on validation failure; customizing requires @ControllerAdvice with @ExceptionHandler for MethodArgumentNotValidException

B Spring Boot returns HTTP 500 on validation errors unless you add @ResponseStatus on the DTO class

C Validation errors are ignored by default and must be manually checked in controller methods

D You must implement HandlerInterceptor to catch validation errors globally

💡 Hint

Think about default behavior and how to override it cleanly.

Spring Boot returns HTTP 400 with a default error response for validation failures. To customize, use @ControllerAdvice and handle MethodArgumentNotValidException.

Practice

1. What is the main purpose of validation error responses in a Spring Boot application?

easy

A. To speed up the application startup time

B. To inform users about incorrect input so they can fix it

C. To log errors only for developers without user feedback

D. To automatically correct user input without notification

Solution

1. Step 1: Understand validation error responses

   Validation error responses are designed to tell users what input is wrong so they can correct it.

2. Step 2: Identify the purpose in Spring Boot context

   Spring Boot uses validation error responses to provide clear feedback to users, improving user experience.

3. Final Answer:

   To inform users about incorrect input so they can fix it -> Option B

4. Quick Check:

   Validation error responses = user input feedback [OK]

Hint: Validation errors help users fix input mistakes [OK]

Common Mistakes:

• Thinking validation errors speed up startup
• Assuming errors are only for developer logs
• Believing errors auto-correct input silently

2. Which annotation is used in Spring Boot to trigger validation on a request body object?

easy

A. @Valid

B. @Autowired

C. @RequestBody

D. @Controller

Solution

1. Step 1: Identify annotation for validation

   The @Valid annotation tells Spring Boot to validate the object passed in the request.

2. Step 2: Differentiate from other annotations

   @RequestBody binds the request body, @Autowired injects dependencies, and @Controller marks a class as a controller, none trigger validation.

3. Final Answer:

   @Valid -> Option A

4. Quick Check:

   Validation trigger = @Valid [OK]

Hint: Use @Valid to activate validation on input objects [OK]

Common Mistakes:

• Confusing @RequestBody with validation trigger
• Using @Autowired for validation incorrectly
• Thinking @Controller triggers validation

3. Given this Spring Boot controller method snippet, what will be the HTTP response status if validation fails?

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

medium

A. 400 Bad Request

B. 200 OK

C. 500 Internal Server Error

D. 404 Not Found

Solution

1. Step 1: Understand validation failure behavior

   When validation fails on a @Valid annotated object, Spring Boot returns a 400 Bad Request by default.

2. Step 2: Check the method response

   The method returns 200 OK only if validation passes; failure triggers automatic 400 response.

3. Final Answer:

   400 Bad Request -> Option A

4. Quick Check:

   Validation fail status = 400 Bad Request [OK]

Hint: Validation failure returns 400 Bad Request by default [OK]

Common Mistakes:

• Assuming 200 OK even if validation fails
• Thinking validation failure causes 500 error
• Confusing 404 Not Found with validation errors

4. What is wrong with this Spring Boot exception handler for validation errors?

@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<String> handleValidationError(MethodArgumentNotValidException ex) {
    return ResponseEntity.badRequest().body(ex.getMessage());
}

medium

A. It does not use @Valid annotation

B. It uses the wrong exception class for validation errors

C. It should return HTTP status 500 instead of 400

D. It returns a plain message string instead of detailed field errors

Solution

1. Step 1: Analyze the exception handler response

   The handler returns only the exception message string, which is not user-friendly or field-specific.

2. Step 2: Understand best practice for validation errors

   Best practice is to return a JSON with detailed field error messages for clarity, not just a plain string.

3. Final Answer:

   It returns a plain message string instead of detailed field errors -> Option D

4. Quick Check:

   Validation error response should be detailed JSON [OK]

Hint: Return detailed JSON, not plain strings, for validation errors [OK]

Common Mistakes:

• Using wrong exception class (MethodArgumentNotValidException is correct)
• Returning HTTP 500 instead of 400
• Confusing @Valid usage with exception handling

5. You want to customize validation error responses to return JSON with field names and messages. Which approach correctly achieves this in Spring Boot?

hard

A. Use @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR) on the controller method to handle validation errors

B. Add @Valid to the controller method and rely on default error messages without customization

C. Create a @ControllerAdvice class with @ExceptionHandler for MethodArgumentNotValidException that extracts field errors and returns a JSON map

D. Catch Exception in the controller method and return a plain string message

Solution

1. Step 1: Understand how to customize validation error responses

   Using a @ControllerAdvice with an @ExceptionHandler for MethodArgumentNotValidException allows extracting field errors and returning custom JSON.

2. Step 2: Evaluate other options

   Add @Valid to the controller method and rely on default error messages without customization uses default messages without customization; C uses wrong status; D returns plain string, not JSON.

3. Final Answer:

   Create a @ControllerAdvice class with @ExceptionHandler for MethodArgumentNotValidException that extracts field errors and returns a JSON map -> Option C

4. Quick Check:

   Custom JSON errors = @ControllerAdvice + @ExceptionHandler [OK]

Hint: Use @ControllerAdvice and @ExceptionHandler for custom JSON errors [OK]

Common Mistakes:

• Relying on default messages without customization
• Using wrong HTTP status for validation errors
• Returning plain strings instead of JSON