@NotNull, @NotBlank, @NotEmpty in Spring Boot - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the @NotNull annotation check in Spring Boot validation?

It checks that the annotated field is not null. However, it does not check if the field is empty if it is a String or collection.

beginner

How is @NotBlank different from @NotNull?

@NotBlank checks that a String is not null and also not empty or only whitespace. It is stricter than @NotNull for Strings.

beginner

What type of fields is @NotEmpty used for?

@NotEmpty is used for Strings, Collections, Maps, or arrays to ensure they are not null and not empty (length > 0).

intermediate

Which annotation would you use to ensure a list is not null and has at least one element?

You would use @NotEmpty because it checks both for null and that the collection has at least one element.

intermediate

Can @NotBlank be applied to a List or Collection?

No, @NotBlank is only for CharSequence (like String). For collections, use @NotEmpty to check for non-null and non-empty.

Which annotation ensures a String is not null, not empty, and not just whitespace?

A @NotEmpty

B @NotNull

C @NotBlank

D @Valid

@NotBlank checks for null, empty, and whitespace-only Strings.

Which annotation can be used on a List to ensure it is not null and has elements?

A @NotBlank

B @NotNull

C @Size(min=1)

D @NotEmpty

@NotEmpty ensures the collection is not null and not empty.

What does @NotNull validate?

A Field is not null

B Field is not empty

C Field is not blank

D Field has minimum size

@NotNull only checks that the value is not null.

Which annotation would fail validation for a String with only spaces?

A @NotNull

B @NotBlank

C None of these

D @NotEmpty

@NotBlank fails if the String is only whitespace.

If you want to allow empty strings but not null, which annotation should you use?

A @NotNull

B @NotEmpty

C No annotation needed

D @NotBlank

@NotNull allows empty strings but disallows null values.

Explain the differences between @NotNull, @NotBlank, and @NotEmpty annotations in Spring Boot validation.

Think about what each annotation checks for and on which data types.

Describe a real-life example where you would use @NotBlank instead of @NotNull.

Consider a form field where blank spaces should not be accepted.

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