@Size for length constraints in Spring Boot - Step-by-Step Execution

Concept Flow - @Size for length constraints

Start: Object creation

↓

Validate field length with @Size

↓

Check if length >= min and <= max

↓

Pass validation

↓

Return validation result

When an object is created, the @Size annotation checks if a field's length is within the min and max limits, passing or failing validation accordingly.

Execution Sample

Spring Boot

import javax.validation.constraints.Size;

public class User {
  @Size(min=3, max=10)
  private String username;

  // constructor, getters, setters
}

This code defines a User class where the username must be between 3 and 10 characters long.

Execution Table

Step	Field Value	Length	Condition (3 <= length <= 10)	Validation Result
1	"Jo"	2	2 < 3 (False)	Fail: too short
2	"John"	4	4 >= 3 and 4 <= 10 (True)	Pass
3	"AlexanderTheGreat"	17	17 > 10 (False)	Fail: too long
4	"Anna"	4	4 >= 3 and 4 <= 10 (True)	Pass

💡 Validation stops after checking the field length against min and max constraints.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4
username	null	"Jo"	"John"	"AlexanderTheGreat"	"Anna"
length	0	2	4	17	4
validationResult	null	Fail	Pass	Fail	Pass

Key Moments - 3 Insights

Why does the validation fail when username is "Jo"?

Because the length 2 is less than the minimum 3, as shown in execution_table step 1.

What happens if the username length is exactly 10?

Validation passes since 10 is within the allowed range, similar to step 2 and 4 where length is between 3 and 10.

Does @Size check the content of the string?

@Size only checks the length, not the characters inside, so any string with length in range passes.

Visual Quiz - 3 Questions

Look at the execution table, what is the validation result when username is "John"?

A Fail: too short

B Pass

C Fail: too long

D No validation

💡 Hint

Check execution_table row 2 under Validation Result column.

At which step does the username length exceed the max allowed length?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the Length and Condition columns in execution_table.

If the min value in @Size was changed to 5, what would happen at step 2?

A Validation would pass

B Validation would fail: too long

C Validation would fail: too short

D No change

💡 Hint

Compare the length 4 at step 2 with new min 5 in variable_tracker.

Concept Snapshot

@Size annotation enforces string length limits.
Syntax: @Size(min=3, max=10)
Checks if string length is between min and max inclusive.
If outside range, validation fails with error.
Used on fields in Spring Boot validation.
Helps ensure input length correctness.

Full Transcript

The @Size annotation in Spring Boot is used to check if a string field's length is within specified minimum and maximum limits. When an object is created or validated, the field value's length is measured. If the length is less than the minimum or greater than the maximum, validation fails and an error is returned. Otherwise, validation passes. For example, a username with @Size(min=3, max=10) must have length between 3 and 10 characters. If the username is "Jo" with length 2, validation fails because it is too short. If the username is "John" with length 4, validation passes. This helps ensure that user input meets length requirements before processing.

Practice

1. What does the @Size annotation do in Spring Boot validation?

easy

A. It ensures a field is not null.

B. It validates if a number is within a range.

C. It checks if a string or collection length is within specified min and max limits.

D. It checks if a string matches a regular expression.

Solution

1. Step 1: Understand the purpose of @Size

   @Size is used to validate the length of strings or collections, not numeric ranges or null checks.

2. Step 2: Identify what @Size checks

   It uses min and max to set length limits on text or collections.

3. Final Answer:

   It checks if a string or collection length is within specified min and max limits. -> Option C

4. Quick Check:

   @Size validates length = C [OK]

Hint: Remember @Size controls length, not value or null checks [OK]

Common Mistakes:

• Confusing @Size with @Min/@Max for numbers
• Thinking @Size checks null values
• Assuming @Size validates patterns

2. Which of the following is the correct way to use @Size to require a string between 5 and 10 characters?

easy

A. @Size(min=5, max=10)

B. @Size(length=5-10)

C. @Size(minLength=5, maxLength=10)

D. @Size(range={5,10})

Solution

1. Step 1: Recall correct @Size syntax

   The correct attributes are min and max for length limits.

2. Step 2: Check each option

   Only @Size(min=5, max=10) uses valid attribute names and syntax.

3. Final Answer:

   @Size(min=5, max=10) -> Option A

4. Quick Check:

   Use min and max attributes = A [OK]

Hint: Use min and max, not length or range attributes [OK]

Common Mistakes:

• Using invalid attribute names like length or range
• Trying to pass a range as a string
• Confusing @Size with other annotations

3. Given this code snippet:

@Size(min=3, max=6)
private String code;

Which input value will pass validation?

medium

A. "ab"

B. "abcde"

C. "abcdefg"

D. ""

Solution

1. Step 1: Understand the length limits

   The string must have length between 3 and 6 characters inclusive.

2. Step 2: Check each input length

   "ab" length is 2 (too short), "abcdefg" length is 7 (too long), "abcde" length is 5 (valid), "" length is 0 (too short).

3. Final Answer:

   "abcde" -> Option B

4. Quick Check:

   Length between 3 and 6 = "abcde" [OK]

Hint: Count characters; must be between min and max [OK]

Common Mistakes:

• Ignoring inclusive limits
• Counting characters incorrectly
• Assuming empty string passes

4. Identify the error in this code snippet:

@Size(min=2, max=5)
private int number;

medium

A. @Size cannot be applied to primitive types like int.

B. min and max values are reversed.

C. Missing @NotNull annotation.

D. max value should be greater than 10.

Solution

1. Step 1: Check @Size target types

   @Size works on strings, collections, arrays, but not on primitive types like int.

2. Step 2: Analyze the code

   The field is an int, so @Size is invalid here and will cause an error.

3. Final Answer:

   @Size cannot be applied to primitive types like int. -> Option A

4. Quick Check:

   @Size only for strings/collections = D [OK]

Hint: Use @Size only on strings or collections, not primitives [OK]

Common Mistakes:

• Applying @Size to numbers
• Confusing @Size with @Min/@Max for numbers
• Ignoring type compatibility

5. You want to validate a list of usernames where each username must be between 4 and 12 characters. Which is the correct way to apply @Size in your Spring Boot model?

hard

A. @Size(min=4, max=12) private List<@Size(min=4, max=12)> usernames;

B. @Size(min=4, max=12) private String[] usernames;

C. @Size(min=4, max=12) private List<String> usernames;

D. private List<@Size(min=4, max=12) String> usernames;

Solution

1. Step 1: Understand @Size on collections vs elements

   @Size on a collection checks the collection size, not each element's length.

2. Step 2: Apply @Size to elements inside the collection

   To validate each username's length, use @Size on the generic type parameter or element level.

3. Step 3: Analyze options

   private List<@Size(min=4, max=12) String> usernames; correctly applies @Size to each String element in the List.

4. Final Answer:

   private List<@Size(min=4, max=12) String> usernames; -> Option D

5. Quick Check:

   Use @Size on elements for per-item length = D [OK]

Hint: Put @Size on list elements, not just the list itself [OK]

Common Mistakes:

• Applying @Size only on the list, not elements
• Using invalid syntax for generic annotations
• Confusing collection size with element length