@Min, @Max for numeric constraints in Spring Boot - Step-by-Step Execution

Concept Flow - @Min, @Max for numeric constraints

Start: Input value

↓

Check @Min constraint

Yes / No↓

Error

Yes / No↓

Error

↓

End

The input value is checked first against the minimum allowed value (@Min). If it fails, an error is raised. If it passes, it is then checked against the maximum allowed value (@Max). Passing both means the value is accepted.

Execution Sample

Spring Boot

@Min(10)
@Max(20)
private int age;

This code sets numeric constraints on 'age' so it must be between 10 and 20 inclusive.

Execution Table

Step	Input Value	Check @Min(10)	Check @Max(20)	Result
1	5	5 >= 10? False	Skipped	Error: value below minimum
2	10	10 >= 10? True	10 <= 20? True	Accepted
3	15	15 >= 10? True	15 <= 20? True	Accepted
4	25	25 >= 10? True	25 <= 20? False	Error: value above maximum
5	20	20 >= 10? True	20 <= 20? True	Accepted
6	9	9 >= 10? False	Skipped	Error: value below minimum

💡 Execution stops after checking both constraints or after the first failure.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6
inputValue	N/A	5	10	15	25	20	9
minCheck	N/A	False	True	True	True	True	False
maxCheck	N/A	N/A	True	True	False	True	N/A
result	N/A	Error	Accepted	Accepted	Error	Accepted	Error

Key Moments - 2 Insights

Why is the @Max check skipped when the @Min check fails?

Because the value already fails the minimum constraint, the validation stops early to save time, as shown in rows 1 and 6 of the execution_table.

Can a value equal to @Min or @Max pass validation?

Yes, the constraints are inclusive. Values equal to @Min or @Max pass, as shown in rows 2 and 5 where 10 and 20 are accepted.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result when input value is 25?

A Accepted

B Error: value below minimum

C Error: value above maximum

D Skipped

💡 Hint

Check row 4 in the execution_table for input 25 and the result column.

At which step does the input value fail the @Min constraint?

A Step 2

B Step 1

C Step 3

D Step 5

💡 Hint

Look at the minCheck column in the execution_table for the first False value.

If the input value is 15, what will be the result after validation?

A Accepted

B Error: value below minimum

C Error: value above maximum

D Skipped

💡 Hint

Refer to row 3 in the execution_table for input 15 and the result.

Concept Snapshot

@Min and @Max annotations set inclusive numeric limits on fields.
Validation checks @Min first; if failed, stops with error.
If @Min passes, checks @Max; if failed, error.
If both pass, value is accepted.
Use on numeric fields to enforce range constraints.

Full Transcript

This visual execution trace shows how Spring Boot's @Min and @Max annotations validate numeric values. The input value is first checked against the minimum allowed value using @Min. If the value is less than this minimum, validation stops immediately with an error. If it passes, the value is then checked against the maximum allowed value using @Max. If the value exceeds this maximum, validation fails with an error. Only values within the inclusive range defined by @Min and @Max are accepted. The execution table demonstrates this with example values, showing which checks pass or fail and the resulting validation outcome. Key moments clarify why checks stop early and that boundary values are accepted. The quiz questions help reinforce understanding by referencing specific steps and results from the execution table.

Practice

1.

What is the main purpose of using @Min and @Max annotations in Spring Boot?

easy

A. To define the length of a string

B. To enforce minimum and maximum numeric values on fields

C. To format dates in a specific pattern

D. To mark a method as a REST endpoint

Solution

1. Step 1: Identify purpose of @Min and @Max

   @Min and @Max set numeric limits on fields to ensure values stay within a range. Formatting dates, string length, and REST endpoints are unrelated.

2. Final Answer:

   To enforce minimum and maximum numeric values on fields -> Option B

3. Quick Check:

   @Min/@Max = numeric limits [OK]

Hint: Remember: @Min/@Max control numbers, not strings or dates [OK]

Common Mistakes:

• Confusing @Min/@Max with string length annotations
• Thinking they format dates
• Assuming they define REST endpoints

2.

Which of the following is the correct way to apply @Min and @Max annotations on an integer field age to restrict it between 18 and 65?

public class Person {
    // Which is correct?
    private int age;
}

easy

A. @Min(18) @Max(65) private int age;

B. @Min=18 @Max=65 private int age;

C. @Min{18} @Max{65} private int age;

D. @Min:18 @Max:65 private int age;

Solution

1. Step 1: Verify annotation syntax

   Annotations use parentheses with values, e.g., @Min(18), not =, {} or :. @Min(18) @Max(65) private int age; is correct; others invalid.

2. Final Answer:

   @Min(18) @Max(65) private int age; -> Option A

3. Quick Check:

   Annotations use (value) [OK]

Hint: Annotations always use parentheses for values [OK]

Common Mistakes:

• Using = or {} instead of () in annotations
• Forgetting to import javax.validation.constraints.*
• Placing annotations incorrectly outside the field

3.

Given the following Spring Boot entity snippet, what will happen if score is set to 105?

public class GameScore {
    @Min(0)
    @Max(100)
    private int score;

    // getters and setters
}

medium

A. Validation will fail because 105 is greater than the max 100

B. The value 105 will be accepted without error

C. Validation will fail because 105 is less than the min 0

D. The application will throw a NullPointerException

Solution

1. Step 1: Evaluate constraint for value 105

   @Min(0) requires >= 0; @Max(100) requires <= 100. 105 > 100 violates @Max, triggering validation failure.

2. Final Answer:

   Validation will fail because 105 is greater than the max 100 -> Option A

3. Quick Check:

   Value > @Max = error [OK]

Hint: Values outside @Min/@Max cause validation errors [OK]

Common Mistakes:

• Assuming values above max are accepted
• Confusing min and max roles
• Expecting runtime exceptions instead of validation errors

4.

Identify the error in this code snippet that uses @Min and @Max:

public class Product {
    @Min(1)
    @Max(100)
    private String quantity;

    // getters and setters
}

medium

A. No error, code is correct

B. The values 1 and 100 are invalid for @Min and @Max

C. Missing @NotNull annotation on quantity

D. Annotations @Min and @Max cannot be applied to String fields

Solution

1. Step 1: Check field type compatibility

   @Min/@Max apply only to numeric types (int, long, etc.), not String. quantity is String, causing validation error.

2. Final Answer:

   Annotations @Min and @Max cannot be applied to String fields -> Option D

3. Quick Check:

   @Min/@Max require numeric fields [OK]

Hint: Use @Min/@Max only on numbers, not strings [OK]

Common Mistakes:

• Applying @Min/@Max on non-numeric types
• Assuming @NotNull fixes type issues
• Ignoring type mismatch errors

5.

You want to create a Spring Boot model field rating that only accepts values from 1 to 5 inclusive. Which of the following code snippets correctly enforces this using @Min and @Max?

hard

A. public class Review {
@Min(0)
@Max(5)
private int rating;
}

B. public class Review {
@Min(1)
@Max(6)
private int rating;
}

C. public class Review {
@Min(1)
@Max(5)
private int rating;
}

D. public class Review {
@Min(1)
@Max(5)
private String rating;
}

Solution

1. Step 1: Select correct range and type

   1-5 inclusive requires @Min(1) @Max(5) on int. public class Review { @Min(1) @Max(5) private int rating; } matches; @Min(0) allows 0, @Max(6) allows 6, String invalid.

2. Final Answer:

   public class Review { @Min(1) @Max(5) private int rating; } -> Option C

3. Quick Check:

   @Min(1)/@Max(5) on int [OK]

Hint: Use int with @Min(1) and @Max(5) for rating 1-5 [OK]

Common Mistakes:

• Using wrong numeric ranges
• Applying annotations on String fields
• Setting min or max outside desired range