@Min, @Max for numeric constraints in Spring Boot - Mini Project: Build & Apply

Using @Min and @Max for Numeric Validation in Spring Boot

📖 Scenario: You are building a simple Spring Boot application that accepts user input for product quantities. You want to make sure the quantity is never less than 1 and never more than 100.

🎯 Goal: Create a Spring Boot model class with a numeric field quantity that uses @Min and @Max annotations to enforce these limits.

📋 What You'll Learn

Create a model class named OrderItem

Add an integer field named quantity

Use @Min(1) annotation on quantity

Use @Max(100) annotation on quantity

Include getter and setter for quantity

💡 Why This Matters

🌍 Real World

Numeric constraints like @Min and @Max help ensure data integrity in applications, such as limiting order quantities or age inputs.

💼 Career

Understanding validation annotations is essential for backend developers working with Spring Boot to build robust and user-friendly APIs.

1

Create the OrderItem class with quantity field

Create a public class named OrderItem and add a private integer field called quantity.

Spring Boot

public class OrderItem {
    // Your code here
}

Hint

Define the class and then declare the quantity field as an integer.

2

Add @Min annotation to quantity

Add the @Min(1) annotation above the quantity field to ensure the minimum value is 1. Import javax.validation.constraints.Min.

Spring Boot

import javax.validation.constraints.Min;

public class OrderItem {
    // Add @Min(1) annotation here
    private int quantity;
}

Hint

Place @Min(1) directly above the quantity field.

3

Add @Max annotation to quantity

Add the @Max(100) annotation above the quantity field to ensure the maximum value is 100. Import javax.validation.constraints.Max.

Spring Boot

import javax.validation.constraints.Max;

public class OrderItem {
    @Min(1)
    // Add @Max(100) annotation here
    private int quantity;
}

Hint

Place @Max(100) directly above the quantity field, below @Min(1).

4

Add getter and setter for quantity

Add a public getter method named getQuantity() and a public setter method named setQuantity(int quantity) for the quantity field.

Spring Boot

import javax.validation.constraints.Min;
import javax.validation.constraints.Max;

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

    // Add getter and setter methods here
}

Hint

Write standard getter and setter methods for the quantity field.

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