@Email and @Pattern in Spring Boot

Introduction

These annotations help check if text inputs follow rules like a valid email or a specific pattern. They make sure data is correct before saving or using it.

When you want to check if a user's email address is valid before saving it.

When you need to make sure a phone number matches a certain format.

When you want to validate form inputs like postal codes or usernames.

When you want to avoid bad data entering your system by checking patterns.

When you want to give users quick feedback on wrong input formats.

Syntax

Spring Boot

@Email(message = "error message")
@Pattern(regexp = "regex", message = "error message")

@Email checks if a string looks like a real email address.

@Pattern checks if a string matches the given regular expression (regex).

Examples

This checks if the email field contains a valid email format.

Spring Boot

@Email(message = "Please enter a valid email")
private String email;

This checks if the phoneNumber has exactly 10 digits.

Spring Boot

@Pattern(regexp = "\\d{10}", message = "Must be 10 digits")
private String phoneNumber;

This ensures the username contains only letters and numbers.

Spring Boot

@Pattern(regexp = "^[A-Za-z0-9]+$", message = "Only letters and numbers allowed")
private String username;

Sample Program

This program creates a User with an email and phone number. It uses @Email and @Pattern to check if the inputs are correct. If all are valid, it prints a success message. Otherwise, it prints the error messages.

Spring Boot

import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.Valid;
import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;
import jakarta.validation.ConstraintViolation;
import java.util.Set;

public class User {
    @Email(message = "Invalid email format")
    private String email;

    @Pattern(regexp = "\\d{3}-\\d{3}-\\d{4}", message = "Phone must be in format XXX-XXX-XXXX")
    private String phone;

    public User(String email, String phone) {
        this.email = email;
        this.phone = phone;
    }

    public static void main(String[] args) {
        User user = new User("[e-mail]", "123-456-7890");

        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();

        Set<ConstraintViolation<User>> violations = validator.validate(user);

        if (violations.isEmpty()) {
            System.out.println("All inputs are valid.");
        } else {
            for (ConstraintViolation<User> violation : violations) {
                System.out.println(violation.getMessage());
            }
        }
    }
}

Important Notes

Remember to add the dependency for jakarta.validation (Bean Validation) in your project to use these annotations.

@Email only checks the format, not if the email actually exists.

Regex in @Pattern must be double escaped in Java strings (\\).

Summary

@Email and @Pattern help check if text inputs follow rules.

Use @Email for emails and @Pattern for custom formats.

They improve data quality and user feedback in your apps.

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