@Valid annotation on request body in Spring Boot - Performance & Optimization

Performance: @Valid annotation on request body

MEDIUM IMPACT

This affects server-side request validation timing and can indirectly impact user experience by delaying response time if validation is slow.

Validating user input in a REST API request body

Spring Boot

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

// User class with validation annotations
public class User {
  @NotBlank
  private String name;
  // getters and setters
}

Delegates validation to Spring's optimized validation framework, reducing manual code and improving maintainability.

📈 Performance GainValidation is optimized and runs before controller logic; reduces CPU overhead and speeds up error handling.

Validating user input in a REST API request body

Spring Boot

public ResponseEntity<String> createUser(@RequestBody User user) {
  // manual validation logic here
  if(user.getName() == null || user.getName().isEmpty()) {
    return ResponseEntity.badRequest().body("Name is required");
  }
  // more manual checks
  return ResponseEntity.ok("User created");
}

Manual validation is error-prone, verbose, and can slow down request processing if complex checks are repeated.

📉 Performance CostBlocks request processing longer due to manual checks; increases server CPU usage.

Performance Comparison

Pattern	CPU Usage	Latency Impact	Error Handling Speed	Verdict
Manual validation in controller	High due to repeated checks	Increases latency by milliseconds	Slower error response	[X] Bad
@Valid annotation with standard constraints	Low to moderate, optimized by framework	Minimal latency added	Fast error response	[OK] Good

Rendering Pipeline

When a request arrives, Spring deserializes the JSON body, then runs validation on the resulting object before entering controller logic. Validation errors short-circuit processing and return errors quickly.

→Request Deserialization

→Validation

→Controller Execution

⚠️ BottleneckValidation stage can add latency if complex or many constraints exist.

Core Web Vital Affected

INP

This affects server-side request validation timing and can indirectly impact user experience by delaying response time if validation is slow.

Optimization Tips

1Use @Valid to delegate validation to Spring's optimized framework.

2Avoid complex or expensive custom validators to reduce latency.

3Fast validation improves server response time and user input responsiveness.

Performance Quiz - 3 Questions

What is the main performance benefit of using @Valid on a request body in Spring Boot?

A It delays validation until after controller logic runs.

B It caches all requests to speed up processing.

C It delegates validation to an optimized framework, reducing manual CPU overhead.

D It disables validation to improve speed.

DevTools: Network

How to check: Open DevTools Network tab, send a request with invalid data, and observe response time and status code.

What to look for: Quick 400 response with validation error message indicates efficient validation; long delays suggest inefficient validation.

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