@Min, @Max for numeric constraints in Spring Boot

Introduction

@Min and @Max help make sure numbers stay within limits you set. This stops wrong or unexpected numbers from causing problems.

When you want to check that a user's age is not less than 18 or more than 100.

When you need to limit a product quantity between 1 and 10 in an order form.

When you want to ensure a rating score is between 0 and 5.

When you want to validate numeric input in a form before saving to the database.

Syntax

Spring Boot

@Min(value)
@Max(value)

// Example:
@Min(1)
@Max(10)
private int quantity;

Use these annotations on numeric fields like int, long, or their wrapper classes.

The value inside @Min or @Max is the limit number you want to enforce.

Examples

This means age cannot be less than 18.

Spring Boot

@Min(18)
private int age;

This means age cannot be more than 100.

Spring Boot

@Max(100)
private int age;

This means rating must be between 1 and 5 inclusive.

Spring Boot

@Min(1)
@Max(5)
private int rating;

Sample Program

This program creates a Product class with a quantity field limited between 1 and 10 using @Min and @Max.

It then validates three products: one valid (5), one too low (0), and one too high (15).

The program prints validation results for each product.

Spring Boot

import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.Max;
import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;
import jakarta.validation.ConstraintViolation;
import java.util.Set;

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

    public Product(int quantity) {
        this.quantity = quantity;
    }

    public int getQuantity() {
        return quantity;
    }

    public static void main(String[] args) {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();

        Product p1 = new Product(5);
        Product p2 = new Product(0);
        Product p3 = new Product(15);

        validateProduct(p1, validator);
        validateProduct(p2, validator);
        validateProduct(p3, validator);
    }

    private static void validateProduct(Product product, Validator validator) {
        Set<ConstraintViolation<Product>> violations = validator.validate(product);
        if (violations.isEmpty()) {
            System.out.println("Product quantity " + product.getQuantity() + " is valid.");
        } else {
            for (ConstraintViolation<Product> violation : violations) {
                System.out.println("Validation error: " + violation.getMessage());
            }
        }
    }
}

Important Notes

These annotations work with Jakarta Bean Validation (JSR 380).

Make sure to have a validation provider like Hibernate Validator in your project.

Validation messages can be customized if needed.

Summary

@Min and @Max check that numbers stay within your set limits.

Use them on numeric fields to avoid invalid input.

They help keep your data clean and your app safe.

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