@NotNull, @NotBlank, @NotEmpty in Spring Boot - Mini Project: Build & Apply

Using @NotNull, @NotBlank, and @NotEmpty in Spring Boot Validation

📖 Scenario: You are building a simple Spring Boot application to register users. You want to make sure the user data is valid before saving it.

🎯 Goal: Learn how to use the validation annotations @NotNull, @NotBlank, and @NotEmpty on a user data class to enforce input rules.

📋 What You'll Learn

Create a User class with fields for name, email, and roles

Use @NotNull on the roles list to ensure it is not null

Use @NotBlank on the email field to ensure it is not empty or just spaces

Use @NotEmpty on the name field to ensure it is not empty

Add the necessary imports for validation annotations

💡 Why This Matters

🌍 Real World

Validating user input in web applications to prevent bad or missing data before saving to a database.

💼 Career

Understanding and applying validation annotations is essential for backend developers working with Spring Boot to build reliable APIs.

1

Create the User class with fields

Create a public class called User with three fields: String name, String email, and List<String> roles. Do not add any annotations yet.

Spring Boot

public class User {
    // Your code here
}

Hint

Think of User as a box holding name, email, and roles information.

2

Add validation imports

Add import statements for javax.validation.constraints.NotNull, javax.validation.constraints.NotBlank, and javax.validation.constraints.NotEmpty at the top of the User class file.

Spring Boot

// Add the three import statements here
import java.util.List;

public class User {
    String name;
    String email;
    List roles;
}

Hint

These imports bring in the validation rules you will use on the fields.

3

Add validation annotations to fields

Add @NotEmpty above the name field, @NotBlank above the email field, and @NotNull above the roles field in the User class.

Spring Boot

import java.util.List;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;

public class User {
    // Add @NotEmpty here
    String name;
    // Add @NotBlank here
    String email;
    // Add @NotNull here
    List roles;
}

Hint

Each annotation enforces a different rule: @NotEmpty means the name cannot be empty, @NotBlank means email cannot be blank or spaces, and @NotNull means roles list cannot be null.

4

Complete the User class with public access and add getters

Make the User class public and add public getter methods for name, email, and roles fields.

Spring Boot

import java.util.List;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;

// Make class public and add getters
public class User {
    @NotEmpty
    String name;

    @NotBlank
    String email;

    @NotNull
    List roles;

    // Your code here
}

Hint

Getters allow other parts of the program to read the field values safely.

Practice

1. Which annotation ensures a string field in a Spring Boot application is not null, but allows empty strings?

easy

A. @NotEmpty

B. @NotBlank

C. @NotNull

D. @Valid

Solution

1. Step 1: Understand @NotNull behavior

   @NotNull only prevents the value from being null but allows empty strings or collections.

2. Step 2: Compare with other annotations

   @NotEmpty and @NotBlank prevent empty values, so they are stricter than @NotNull.

3. Final Answer:

   @NotNull -> Option C

4. Quick Check:

   @NotNull allows empty but not null [OK]

Hint: Remember: @NotNull forbids null, allows empty [OK]

Common Mistakes:

• Confusing @NotNull with @NotEmpty or @NotBlank
• Thinking @NotNull forbids empty strings
• Assuming @Valid checks null automatically

2. Which of the following is the correct way to annotate a string field that must not be null, empty, or only spaces in Spring Boot?

easy

A. @NotBlank private String name;

B. @NotEmpty private String name;

C. @NotNull @NotEmpty private String name;

D. @NotNull private String name;

Solution

1. Step 1: Identify annotation that forbids null, empty, and spaces

   @NotBlank ensures the string is not null, not empty, and not just whitespace.

2. Step 2: Check other options

   @NotNull allows empty or spaces; @NotEmpty forbids empty but allows spaces; only @NotBlank covers all three.

3. Final Answer:

   @NotBlank private String name; -> Option A

4. Quick Check:

   @NotBlank forbids null, empty, spaces [OK]

Hint: Use @NotBlank for strings with no spaces or empties [OK]

Common Mistakes:

• Using @NotEmpty but ignoring spaces
• Combining @NotNull and @NotEmpty unnecessarily
• Assuming @NotNull forbids empty strings

3. Given the code snippet:

@NotEmpty
private List<String> tags;

What happens if tags is set to an empty list during validation?

medium

A. Validation passes because list is not null

B. Validation fails because list is empty

C. Validation fails only if list is null

D. Validation passes regardless of list content

Solution

1. Step 1: Understand @NotEmpty on collections

   @NotEmpty forbids null or empty collections, so empty list fails validation.

2. Step 2: Compare with other annotations

   @NotNull allows empty list; @NotEmpty forbids empty; @NotBlank is for strings only.

3. Final Answer:

   Validation fails because list is empty -> Option B

4. Quick Check:

   @NotEmpty forbids empty collections [OK]

Hint: @NotEmpty forbids empty lists or strings [OK]

Common Mistakes:

• Thinking empty list passes @NotEmpty
• Confusing @NotEmpty with @NotNull
• Applying @NotBlank to collections

4. Consider this code snippet:

@NotBlank
private String title;

Which of the following values for title will cause validation to fail with @NotBlank but pass with @NotEmpty?

medium

A. " " (string with spaces only)

B. "Hello"

C. "" (empty string)

D. null

Solution

1. Step 1: Understand @NotBlank validation rules

   @NotBlank forbids null, empty, and strings with only whitespace.

2. Step 2: Analyze each value

   null and "" fail both @NotBlank and @NotEmpty; "Hello" passes both; " " passes @NotEmpty (length > 0) but fails @NotBlank (trimmed length = 0).

3. Final Answer:

   " " (string with spaces only) -> Option A

4. Quick Check:

   @NotBlank forbids spaces-only strings [OK]

Hint: @NotBlank forbids spaces-only strings [OK]

Common Mistakes:

• Assuming empty string passes @NotBlank
• Confusing @NotBlank with @NotEmpty
• Ignoring spaces-only strings as invalid

5. You want to validate a user input field description that must not be null, empty, or only spaces, but also must allow strings like "0" or "false". Which annotation should you use in Spring Boot?

hard

A. @Size(min=1)

B. @NotEmpty

C. @NotNull

D. @NotBlank

Solution

1. Step 1: Understand requirements for description

   Must not be null, empty, or spaces-only, but allow "0" or "false" strings.

2. Step 2: Match annotation behavior

   @NotBlank forbids null, empty, and spaces-only strings but allows "0" and "false" as they are non-blank strings.

3. Step 3: Check alternatives

   @NotNull allows empty; @NotEmpty forbids empty but allows spaces; @Size(min=1) forbids empty but not spaces-only.

4. Final Answer:

   @NotBlank -> Option D

5. Quick Check:

   @NotBlank fits all conditions [OK]

Hint: Use @NotBlank to forbid null, empty, and spaces-only [OK]

Common Mistakes:

• Using @NotEmpty and missing spaces-only strings
• Assuming @Size(min=1) forbids spaces-only
• Confusing @NotNull with stricter annotations