@Min, @Max for numeric constraints in Spring Boot - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the @Min annotation in Spring Boot?

The @Min annotation ensures that a numeric value is not less than a specified minimum value. It helps validate input data by enforcing a lower limit.

beginner

How does the @Max annotation work in Spring Boot validation?

The @Max annotation checks that a numeric value does not exceed a specified maximum value. It prevents values greater than the limit from being accepted.

intermediate

Can @Min and @Max be used together on the same field? What does that achieve?

Yes, using @Min and @Max together sets a range for valid numeric input. The value must be between the minimum and maximum limits inclusive.

beginner

What happens if a value violates the @Min or @Max constraint in Spring Boot?

If the value is outside the allowed range, Spring Boot validation fails and returns an error message. This helps prevent invalid data from being processed.

beginner

Show a simple example of using @Min and @Max on a field in a Spring Boot model class.

Example:
<pre>import javax.validation.constraints.Min;
import javax.validation.constraints.Max;

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

  // getters and setters
}</pre>
This means quantity must be between 1 and 100.

What does @Min(5) enforce on a numeric field?

A Value must be exactly 5

B Value must be at most 5

C Value must be at least 5

D Value must be between 0 and 5

@Min(5) means the value cannot be less than 5.

Which annotation ensures a number is not greater than a limit?

A @Max

B @Min

C @Size

D @NotNull

@Max sets the maximum allowed value.

If a field has @Min(1) and @Max(10), which value is invalid?

A 5

B 1

C 10

D 15

15 is greater than the max limit 10, so it is invalid.

What type of values can @Min and @Max be applied to?

A Numeric types like int, long, double

B Only Strings

C Boolean values

D Any object

@Min and @Max validate numeric values.

What happens if validation fails for @Min or @Max in Spring Boot?

A The application crashes

B An error message is returned

C The value is automatically corrected

D Nothing happens

Validation failure returns an error message to inform the user.

Explain how @Min and @Max annotations help in validating numeric input in Spring Boot.

Think about setting minimum and maximum allowed values.

Describe a real-life example where you would use @Min and @Max annotations in a Spring Boot application.

Consider a form input that must stay within a range.

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