Why input validation is critical in Spring Boot - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to add input validation annotation for a non-empty string in Spring Boot.

Spring Boot

@NotBlank(message = "Name cannot be empty")
private String [1];

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

Ausername

Bprice

Cage

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using a numeric field like age or price with @NotBlank causes errors.

Leaving the field name blank or misspelled.

The @NotBlank annotation is used to ensure the string is not empty or null. Here, it is applied to the username field to validate user input.

2fill in blank

medium

Complete the code to validate that an integer input is at least 18 in Spring Boot.

Spring Boot

@Min(value = [1], message = "Age must be at least 18")
private int age;

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

A16

B0

C18

D21

Attempts:

3 left

💡 Hint

Common Mistakes

Using a value less than 18 allows invalid ages.

Using a value greater than 18 unnecessarily restricts input.

The @Min annotation ensures the integer value is not less than the specified minimum. Here, it validates that age is at least 18.

3fill in blank

hard

Fix the error in the code to correctly validate an email input in Spring Boot.

Spring Boot

@Email(message = "Invalid email format")
private String [1];

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

AphoneNumber

Busername

Cpassword

DemailAddress

Attempts:

3 left

💡 Hint

Common Mistakes

Applying email validation to phone number or password fields.

Using a field name unrelated to email.

The @Email annotation validates that the string is a valid email format. It should be applied to the emailAddress field.

4fill in blank

hard

Fill both blanks to create a validated DTO class with a non-null name and age at least 21.

Spring Boot

public class UserDTO {
    @[1](message = "Name is required")
    private String name;

    @[2](value = 21, message = "Must be at least 21")
    private int age;
}

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

ANotNull

BMin

CNotBlank

DMax

Attempts:

3 left

💡 Hint

Common Mistakes

Using @NotNull instead of @NotBlank for strings allows empty names.

Using @Max instead of @Min for age validation.

@NotBlank ensures the name is not null or empty. @Min(21) ensures age is at least 21.

5fill in blank

hard

Fill all three blanks to create a Spring Boot controller method that validates input and returns a response.

Spring Boot

@PostMapping("/register")
public ResponseEntity<String> registerUser(@Valid @RequestBody [1] user) {
    if (user.getAge() [2] 18) {
        return ResponseEntity.status(HttpStatus.[3]).body("User too young");
    }
    return ResponseEntity.ok("User registered");
}

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

AUserDTO

B<

CFORBIDDEN

DUserEntity

Attempts:

3 left

💡 Hint

Common Mistakes

Using entity class instead of DTO for input validation.

Using wrong comparison operator like '>' instead of '<'.

Returning wrong HTTP status code.

The method accepts a validated UserDTO object. It checks if age is less than 18. If so, it returns a 403 FORBIDDEN status with a message.

Practice

1. Why is input validation critical in a Spring Boot application?

easy

A. It helps prevent invalid or harmful data from entering the system.

B. It makes the application run faster by skipping checks.

C. It automatically fixes user mistakes without notifying them.

D. It allows users to enter any data without restrictions.

Solution

1. Step 1: Understand the purpose of input validation

   Input validation ensures that data coming from users meets expected rules and formats.

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

   This prevents harmful or incorrect data from causing errors or security issues in the app.

3. Final Answer:

   It helps prevent invalid or harmful data from entering the system. -> Option A

4. Quick Check:

   Input validation = prevent bad data [OK]

Hint: Input validation stops bad data before it breaks things [OK]

Common Mistakes:

• Thinking validation speeds up app by skipping checks
• Believing validation fixes user errors silently
• Assuming validation allows all data without limits

2. Which annotation is used in Spring Boot to ensure a field is not null during input validation?

easy

A. @Email

B. @Valid

C. @Size

D. @NotNull

Solution

1. Step 1: Recall common validation annotations

   @NotNull ensures a field must have a value and cannot be null.

2. Step 2: Differentiate from other annotations

   @Email checks email format, @Size checks length, and @Valid triggers validation on nested objects.

3. Final Answer:

   @NotNull -> Option D

4. Quick Check:

   @NotNull = no null allowed [OK]

Hint: Use @NotNull to block empty fields [OK]

Common Mistakes:

• Confusing @Email with @NotNull
• Using @Valid instead of @NotNull for null checks
• Thinking @Size checks for null values

3. Given this Spring Boot controller method snippet:

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

What happens if the user object has an invalid email format and @Email is used on the email field?

medium

A. The server crashes with an exception.

B. The method runs normally and registers the user.

C. Spring Boot returns a 400 Bad Request error automatically.

D. The invalid email is saved without error.

Solution

1. Step 1: Understand @Valid and @Email behavior

   @Valid triggers validation on the User object, and @Email checks the email format.

2. Step 2: Identify Spring Boot's response to validation failure

   If validation fails, Spring Boot automatically returns a 400 Bad Request response without running the method body.

3. Final Answer:

   Spring Boot returns a 400 Bad Request error automatically. -> Option C

4. Quick Check:

   Invalid input = 400 error [OK]

Hint: Invalid input with @Valid triggers 400 error [OK]

Common Mistakes:

• Assuming method runs despite invalid input
• Thinking server crashes instead of handling error
• Believing invalid data is saved silently

4. Consider this code snippet in a Spring Boot app:

public class User {
    @NotNull
    private String name;

    @Email
    private String email;

    // getters and setters
}

Why might the validation fail even if the user provides a valid email and name?

medium

A. Because the controller method is missing the @Valid annotation on the User parameter.

B. Because @NotNull does not check for empty strings.

C. Because @Email only works on numbers, not strings.

D. Because getters and setters are not annotated.

Solution

1. Step 1: Check validation trigger in Spring Boot

   Validation annotations like @NotNull and @Email require @Valid on the controller method parameter to activate validation.

2. Step 2: Understand why validation might not run

   If @Valid is missing, Spring Boot skips validation even if annotations exist on fields.

3. Final Answer:

   Because the controller method is missing the @Valid annotation on the User parameter. -> Option A

4. Quick Check:

   Missing @Valid means no validation [OK]

Hint: Always add @Valid on input parameters to trigger validation [OK]

Common Mistakes:

• Thinking @NotNull checks empty strings
• Believing @Email works on numbers
• Assuming getters/setters need annotations

5. You want to ensure a user's password is at least 8 characters and not null in a Spring Boot app. Which combination of annotations on the password field is best to enforce this?

hard

A. @Email @NotNull

B. @NotNull @Size(min = 8)

C. @Valid @NotEmpty

D. @Size(max = 8) @NotNull

Solution

1. Step 1: Identify annotations for null and length checks

   @NotNull ensures the password is not null, and @Size(min = 8) enforces minimum length of 8 characters.

2. Step 2: Eliminate incorrect options

   @Email is for emails, not passwords; @NotEmpty is similar but less strict than @NotNull; @Size(max = 8) limits max length, not minimum.

3. Final Answer:

   @NotNull @Size(min = 8) -> Option B

4. Quick Check:

   Not null + min length = @NotNull @Size(min=8) [OK]

Hint: Use @NotNull with @Size(min=8) for password rules [OK]

Common Mistakes:

• Using @Email for password validation
• Confusing max length with min length
• Skipping @NotNull and allowing null passwords