@Email and @Pattern in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when @Email validation fails?

Consider a Spring Boot REST controller receiving a user email annotated with @Email. What is the typical behavior when the email format is invalid?

Spring Boot

public class User {
    @Email
    private String email;

    // getters and setters
}

@PostMapping("/register")
public ResponseEntity<String> registerUser(@Valid @RequestBody User user) {
    return ResponseEntity.ok("User registered");
}

A A validation error is thrown and the request returns a 400 Bad Request response automatically.

B The controller method executes normally and saves the user with the invalid email.

C The application crashes with a NullPointerException.

D The invalid email is automatically corrected to a valid format.

💡 Hint

Think about how Spring Boot handles validation annotations with @Valid.

The @Email annotation triggers validation on the email field. When used with @Valid in the controller, Spring Boot automatically checks the input. If the email is invalid, it returns a 400 Bad Request with validation error details.

📝 Syntax

intermediate

Which @Pattern regex correctly validates a 5-digit US ZIP code?

You want to validate a US ZIP code that must be exactly 5 digits using @Pattern. Which regex pattern is correct?

Spring Boot

public class Address {
    @Pattern(regexp = "???", message = "Invalid ZIP code")
    private String zipCode;

    // getters and setters
}

A "[a-zA-Z]{5}"

B "\d{5,}"

C "\\d{5}"

D "[0-9]{4}"

💡 Hint

Remember to escape backslashes in Java strings.

The regex "\\d{5}" matches exactly 5 digits. The double backslash is needed in Java strings to represent a single backslash in the regex.

🔧 Debug

advanced

Why does this @Email validation not work as expected?

Given this code snippet, why does the @Email annotation not trigger validation errors for invalid emails?

Spring Boot

public class Contact {
    @Email
    private String email;

    // getters and setters
}

@PostMapping("/contact")
public String submitContact(@RequestBody Contact contact) {
    return "Received";
}

A Because the @Email annotation requires a custom validator bean to be registered.

B Because @Email only works on fields of type java.net.Email, not String.

C Because the email field is private and needs to be public for validation.

D Because @Valid is missing on the controller method parameter, so validation is not triggered.

💡 Hint

Check how validation is triggered in Spring Boot controllers.

Validation annotations like @Email require the @Valid annotation on the controller method parameter to activate validation. Without @Valid, the annotations are ignored.

🧠 Conceptual

advanced

How does @Pattern differ from @Email in validation?

Which statement best describes the difference between @Pattern and @Email annotations in Spring Boot validation?

A @Email validates only email format, while @Pattern can validate any string against a custom regex.

B @Pattern validates email format, while @Email validates phone numbers.

C @Email and @Pattern are interchangeable and validate the same patterns.

D @Pattern automatically fixes invalid input, @Email only reports errors.

💡 Hint

Think about the purpose of each annotation.

@Email is a specialized annotation for email format validation. @Pattern is a general-purpose annotation that validates strings against any regex pattern you provide.

❓ state_output

expert

What is the validation error message when @Pattern fails?

Given this code snippet, what exact message will be returned if the zipCode does not match the pattern?

Spring Boot

public class Location {
    @Pattern(regexp = "\\d{5}", message = "ZIP code must be 5 digits")
    private String zipCode;

    // getters and setters
}

@PostMapping("/location")
public ResponseEntity<String> addLocation(@Valid @RequestBody Location location) {
    return ResponseEntity.ok("Location added");
}

A "Invalid ZIP code format"

B "ZIP code must be 5 digits"

C "zipCode does not match pattern"

D "Validation failed for zipCode"

💡 Hint

Look at the message attribute in the @Pattern annotation.

The message attribute in @Pattern defines the exact error message returned when validation fails.

Practice

1. What is the primary purpose of the @Email annotation in Spring Boot validation?

easy

A. To convert a string to lowercase

B. To check if a string matches a custom regular expression

C. To ensure a string is not empty

D. To check if a string is a valid email format

Solution

1. Step 1: Understand the role of @Email

   The @Email annotation is designed to validate that a string looks like a proper email address format.

2. Step 2: Compare with other annotations

   @Pattern is used for custom regex, @NotEmpty ensures non-empty, and no annotation converts case automatically.

3. Final Answer:

   To check if a string is a valid email format -> Option D

4. Quick Check:

   @Email = Valid email format [OK]

Hint: Remember: @Email checks email format only [OK]

Common Mistakes:

• Confusing @Email with @Pattern for custom regex
• Thinking @Email checks if field is empty
• Assuming @Email changes string content

2. Which of the following is the correct way to use @Pattern to allow only digits in a Spring Boot entity field?

easy

A. @Pattern(regex = "\\d+")

B. @Pattern(regexp = "\\d+")

C. @Pattern(pattern = "[0-9]*")

D. @Pattern(regexp = "[a-zA-Z]+")

Solution

1. Step 1: Check the correct attribute name

   The correct attribute for @Pattern is regexp, not regex or pattern.

2. Step 2: Validate the regex for digits

   The regex \\d+ matches one or more digits. @Pattern(regexp = "\\d+") uses correct syntax and regex.

3. Final Answer:

   @Pattern(regexp = "\\d+") -> Option B

4. Quick Check:

   @Pattern uses regexp attribute [OK]

Hint: Use regexp attribute, not regex or pattern [OK]

Common Mistakes:

• Using 'regex' instead of 'regexp' attribute
• Using incorrect regex syntax
• Confusing @Pattern attribute names

3. Given this Spring Boot entity field:

@Email
@Pattern(regexp = ".+@example\\.com$")
private String email;

What happens if the user inputs [e-mail]?

medium

A. Validation fails because email does not end with @example.com

B. Validation passes because it is a valid email

C. Validation fails because @Email and @Pattern cannot be used together

D. Validation passes because @Pattern is ignored

Solution

1. Step 1: Understand @Email validation

   @Email checks if the input looks like an email. '[e-mail]' is a valid email format, so it passes this check.

2. Step 2: Understand @Pattern validation

   @Pattern requires the email to end with '@example.com'. '[e-mail]' ends with '@test.com', so it fails this pattern check.

3. Final Answer:

   Validation fails because email does not end with @example.com -> Option A

4. Quick Check:

   @Pattern restricts domain, so input fails [OK]

Hint: Both @Email and @Pattern must pass for validation [OK]

Common Mistakes:

• Assuming @Email alone validates domain
• Thinking @Pattern is ignored if @Email passes
• Believing @Email and @Pattern conflict

4. Consider this code snippet in a Spring Boot entity:

@Email
@Pattern(regexp = "[a-zA-Z]+")
private String userEmail;

Why might this validation cause unexpected failures for typical emails?

medium

A. Because the regex only allows letters, blocking digits and symbols in emails

B. Because @Email does not allow uppercase letters

C. Because @Pattern requires the field to be empty

D. Because @Email and @Pattern cannot be used on the same field

Solution

1. Step 1: Analyze the regex pattern

   The regex [a-zA-Z]+ allows only letters, no digits, dots, or @ symbols which are common in emails.

2. Step 2: Understand impact on email validation

   This pattern blocks valid email characters like digits, dots, and '@', causing valid emails to fail validation.

3. Final Answer:

   Because the regex only allows letters, blocking digits and symbols in emails -> Option A

4. Quick Check:

   Regex must allow email characters [OK]

Hint: Regex must include all valid email characters [OK]

Common Mistakes:

• Assuming @Email restricts uppercase letters
• Thinking @Pattern requires empty field
• Believing @Email and @Pattern conflict

5. You want to validate a Spring Boot entity field so it accepts only emails from mycompany.com domain. Which annotation setup is correct?

hard

A. @Pattern(regexp = ".+@mycompany\\.com$")

B. @Email(regexp = ".+@mycompany\\.com$")

C. @Email
@Pattern(regexp = ".+@mycompany\\.com$")

D. @Email
@Pattern(regexp = "^mycompany.com$")

Solution

1. Step 1: Use @Email for email format validation

   @Email ensures the string is a valid email format regardless of domain.

2. Step 2: Use @Pattern to restrict domain

   @Pattern with regex .+@mycompany\\.com$ ensures the email ends with '@mycompany.com'.

3. Step 3: Check other options

   @Email(regexp = ".+@mycompany\\.com$") is invalid because @Email does not accept regexp attribute. @Pattern(regexp = ".+@mycompany\\.com$") misses email format check. @Email @Pattern(regexp = "^mycompany.com$") regex is incorrect for email domain.

4. Final Answer:

   @Email @Pattern(regexp = ".+@mycompany\\.com$") -> Option C

5. Quick Check:

   Combine @Email and @Pattern for domain restriction [OK]

Hint: Use @Email plus @Pattern with domain regex [OK]

Common Mistakes:

• Trying to put regexp inside @Email
• Using incomplete regex that misses email format
• Incorrect regex anchors for domain