@NotNull, @NotBlank, @NotEmpty in Spring Boot

Introduction

These annotations help check if data is missing or empty before saving or using it. They keep your app safe and correct.

When you want to make sure a user fills in a form field before submitting.

When saving data to a database and you need certain fields to always have values.

When validating API request data to avoid errors caused by missing or empty inputs.

When you want to give clear error messages if required data is missing.

When you want to avoid null or empty values causing bugs later in your code.

Syntax

Spring Boot

@NotNull
@NotEmpty
@NotBlank

@NotNull means the value cannot be null but can be empty if it is a string or collection.

@NotEmpty means the value cannot be null or empty (like an empty string or empty list).

@NotBlank means the value cannot be null, empty, or only spaces (only for strings).

Examples

This means age cannot be null but can be zero.

Spring Boot

@NotNull
private Integer age;

This means tags cannot be null or an empty list.

Spring Boot

@NotEmpty
private List<String> tags;

This means name cannot be null, empty, or just spaces.

Spring Boot

@NotBlank
private String name;

Sample Program

This class uses the three annotations to make sure the user has an ID, roles list, and username filled properly. The main method shows creating a user and printing the values.

Spring Boot

import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;

public class User {

    @NotNull
    private Integer id;

    @NotEmpty
    private List<String> roles;

    @NotBlank
    private String username;

    // Constructor
    public User(Integer id, List<String> roles, String username) {
        this.id = id;
        this.roles = roles;
        this.username = username;
    }

    // Getters
    public Integer getId() { return id; }
    public List<String> getRoles() { return roles; }
    public String getUsername() { return username; }

    public static void main(String[] args) {
        // Example usage
        User user = new User(1, List.of("admin", "user"), "john_doe");
        System.out.println("User ID: " + user.getId());
        System.out.println("Roles: " + user.getRoles());
        System.out.println("Username: " + user.getUsername());
    }
}

Important Notes

These annotations work with Spring Boot's validation system and need a validator to check them at runtime.

@NotBlank only works on strings, so use @NotEmpty for collections or arrays.

Use these annotations on fields or method parameters to automatically validate input data.

Summary

@NotNull means value cannot be null but can be empty.

@NotEmpty means value cannot be null or empty (strings, collections).

@NotBlank means value cannot be null, empty, or spaces (only strings).

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