@Valid annotation on request body in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to enable validation on the request body parameter.

Spring Boot

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

Drag options to blanks, or click blank then click option'

AValid

BAutowired

CRequestParam

DPathVariable

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Autowired instead of @Valid

Forgetting to add @Valid before @RequestBody

Using @RequestParam or @PathVariable which are for different purposes

The @Valid annotation tells Spring Boot to validate the User object based on its validation annotations.

2fill in blank

medium

Complete the code to import the correct package for the @Valid annotation.

Spring Boot

import javax.[1].Valid;

Drag options to blanks, or click blank then click option'

Avalidation.executable

Bvalidation

Cvalidation.metadata

Dvalidation.constraints

Attempts:

3 left

💡 Hint

Common Mistakes

Importing from javax.validation.constraints which is for specific constraint annotations

Importing from unrelated sub-packages

The @Valid annotation is in the javax.validation package.

3fill in blank

hard

Fix the error in the controller method to properly validate the request body.

Spring Boot

public ResponseEntity<String> updateUser(@RequestBody User user) { if(user.getName() == null) { return ResponseEntity.badRequest().body("Name is required"); } return ResponseEntity.ok("User updated"); } // Add [1] to enable automatic validation

Drag options to blanks, or click blank then click option'

A@Validated

B@NotNull

C@RequestParam

D@Valid

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Validated instead of @Valid on method parameters

Not adding any validation annotation

Using @NotNull which is a constraint, not a validation trigger

Adding @Valid before @RequestBody triggers automatic validation of the User object.

4fill in blank

hard

Fill both blanks to create a controller method that validates the request body and returns a response.

Spring Boot

public ResponseEntity<String> addProduct([1] @RequestBody Product product) { if(product.getPrice() [2] 0) { return ResponseEntity.badRequest().body("Price must be positive"); } return ResponseEntity.ok("Product added"); }

Drag options to blanks, or click blank then click option'

A@Valid

B>

C<=

D@Autowired

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Autowired instead of @Valid

Using <= instead of > for price check

Use @Valid to validate the product object and > to check if price is positive.

5fill in blank

hard

Fill all three blanks to create a method that validates a request body and uses a constraint annotation on the model.

Spring Boot

public ResponseEntity<String> registerUser(@[1] @RequestBody User user) { return ResponseEntity.ok("User registered"); } // In User class: private String email; @[2](message="Email is required") @[3] private String email;

Drag options to blanks, or click blank then click option'

AValid

BNotNull

CEmail

DAutowired

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Autowired instead of @Valid

Swapping @NotNull and @Email

Forgetting constraint annotations on the model

Use @Valid on the method parameter, @NotNull to ensure email is not null, and @Email to check email format.

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