@Size for length constraints in Spring Boot - Mini Project: Build & Apply

@Size for length constraints in Spring Boot

📖 Scenario: You are building a simple Spring Boot application to manage user profiles. Each user has a username that must be between 3 and 15 characters long.

🎯 Goal: Create a User class with a username field that uses the @Size annotation to enforce the length constraint. Then, configure a controller to accept user data and validate it.

📋 What You'll Learn

Create a User class with a username field

Use @Size(min = 3, max = 15) on the username field

Create a controller method to accept a User object

Enable validation on the controller method parameter

💡 Why This Matters

🌍 Real World

Length constraints on user input fields are common in web applications to ensure data quality and prevent errors.

💼 Career

Understanding how to use validation annotations like @Size is essential for backend developers working with Spring Boot to build robust APIs.

1

Create the User class with a username field

Create a class called User with a private String field named username.

Spring Boot

public class User {
    // Your code here
}

Hint

Remember to add getter and setter methods for the username field.

2

Add @Size annotation to username field

Add the @Size(min = 3, max = 15) annotation above the username field in the User class. Also, add the import statement for jakarta.validation.constraints.Size.

Spring Boot

import jakarta.validation.constraints.Size;

public class User {
    // Add @Size annotation here
    private String username;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

Hint

The @Size annotation controls the allowed length of the string.

3

Create a controller method to accept User data

Create a Spring Boot controller class called UserController with a method createUser that accepts a @RequestBody User user parameter. Add @PostMapping("/users") above the method.

Spring Boot

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    // Your code here
}

Hint

Use @RestController on the class and @PostMapping on the method.

4

Enable validation on the User parameter

Add the @Valid annotation before the User user parameter in the createUser method. Also, add the import for jakarta.validation.Valid.

Spring Boot

import jakarta.validation.Valid;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    // Add @Valid annotation here
    @PostMapping("/users")
    public void createUser(@RequestBody User user) {
        // Method body can be empty for now
    }
}

Hint

The @Valid annotation triggers validation of the User object.

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