Validateur regex Java d'e-mail

Qu'est-ce que le regex d'e-mail en Java ?

En Java, les patterns regex d'e-mail servent à vérifier que la saisie utilisateur respecte un format d'e-mail valide. Cela inclut la présence d'une partie locale, d'un signe arobase et d'un domaine avec un TLD valide.

Les vérifications de validation typiques couvrent :

• Les caractères alphanumériques

• Les points, tirets et underscores dans les noms d'utilisateur

• Un domaine valide avec au moins un . et 2+ caractères dans l'extension

Adresses e-mail valides vs. invalides

Valides :

• username@domain.com

• user.name@domain.com

• user-name@domain.com

• username@domain.co.in

• user+tag@gmail.com

Invalides :

• username.@domain.com (point final)

• .user.name@domain.com (point initial)

• user..name@domain.com (points consécutifs)

• username@.com (pas de nom de domaine)

Tableau comparatif des patterns regex d'e-mail

Choisissez le pattern adapté à votre cas d'usage :

Exemples de code Java prêts pour la production

Exemple 1 : Validation d'e-mail standard

Essayez dans le Testeur regex Java

import java.util.regex.*;
public class EmailValidator {
private static final Pattern EMAIL_PATTERN = Pattern.compile(
"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
);
public static boolean isValid(String email) {
    return EMAIL_PATTERN.matcher(email).matches();
}

public static void main(String[] args) {
    System.out.println(isValid("user@example.com"));    // true
    System.out.println(isValid("user@.com"));           // false
    System.out.println(isValid("john.doe@company.co.in")); // true
}

}

Exemple 2 : Validation stricte (pas de points consécutifs, limites de longueur)

import java.util.regex.*;
public class StrictEmailValidator {
private static final Pattern STRICT_PATTERN = Pattern.compile(
"^(?=.{1,64}@)[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)" +
"@[^-][A-Za-z0-9-]+(\.[A-Za-z0-9-]+)(\.[A-Za-z]{2,})$"
);
public static void main(String[] args) {
    String[] emails = {
        "user.name@domain.com",      // true
        "user..name@domain.com",     // false (points consécutifs)
        ".user@domain.com",          // false (point initial)
        "username.@domain.com"       // false (point final)
    };
    for (String email : emails) {
        System.out.println(email + ": " + STRICT_PATTERN.matcher(email).matches());
    }
}

}

Exemple 3 : Correspondance insensible à la casse

import java.util.regex.*;
public class CaseInsensitiveEmail {
public static void main(String[] args) {
Pattern pattern = Pattern.compile(
"^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$",
Pattern.CASE_INSENSITIVE
);
Matcher matcher = pattern.matcher("John.Doe@Example.COM");
System.out.println("Email Valid: " + matcher.matches()); // true
}
}

Exemple 4 : Adresses e-mail Unicode / Internationales

Pour valider des e-mails avec des caractères non latins (chinois, cyrillique, arabe), remplacez [A-Za-z] par \p{L} :

import java.util.regex.*;
public class UnicodeEmailValidator {
private static final Pattern UNICODE_PATTERN = Pattern.compile(
"^(?=.{1,64}@)[\p{L}0-9.%+-]+(\.[\p{L}0-9.%+-]+)" +
"@[^-][\p{L}0-9-]+(\.[\p{L}0-9-]+)(\.[\p{L}]{2,})$"
);
}

Exemple 5 : Méthode utilitaire réutilisable

import java.util.regex.*;
public class EmailUtil {
private static final Pattern PATTERN = Pattern.compile(
"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
);
public static boolean isValidEmail(String email) {
    return PATTERN.matcher(email).matches();
}

}

Comment ça fonctionne

1. Collez votre pattern regex et l'e-mail de test dans le validateur ci-dessus.

2. Il utilise Pattern.compile() et Matcher.matches() de Java en coulisses.

3. Voyez instantanément si votre regex correspond correctement à l'adresse e-mail.

Anatomie d'une adresse e-mail

Chaque adresse e-mail comporte trois parties :

• Partie locale : Le nom d'utilisateur avant l'arobase (ex. emma)

• Signe arobase : Le séparateur

• Partie domaine : Le fournisseur après l'arobase (ex. qodex.ai)

Règles de validation à prendre en compte :

• Caractères autorisés : Lettres, chiffres, . _ - + % dans la partie locale

• Restrictions sur les points : Pas de points initiaux, finaux ou consécutifs dans les deux parties

• Limites de longueur : Partie locale max 64 caractères, domaine max 255 caractères

• Format TLD : 2 à 6 caractères alphabétiques (ex. .com, .museum)

• Adressage plus : Les alias de style Gmail comme user+tag@gmail.com doivent être autorisés

Limites du regex RFC 5322 pour les e-mails

Bien que les patterns RFC 5322 visent à suivre les standards officiels des e-mails, ils peuvent introduire des problèmes :

• Trop permissif : Peut autoriser des caractères dangereux pour vos systèmes en aval

• Risques de sécurité : Certains patterns excluent intentionnellement le pipe (|) et le guillemet simple (') pour prévenir l'injection SQL

• Complexité : Les patterns conformes RFC peuvent comporter des centaines de caractères, rendant leur maintenance difficile

Pour la plupart des applications, le pattern Strict ou OWASP du tableau offre le meilleur équilibre entre sécurité et couverture.

Pourquoi utiliser Apache Commons Validator plutôt qu'un regex personnalisé ?

Pour les applications Java en production, envisagez Apache Commons Validator comme alternative :

• Conforme aux standards : Suit les règles RFC 822, gère automatiquement les cas limites

• Support Unicode : Gère les adresses e-mail internationales

• Maintenu : Régulièrement mis à jour par la communauté open source

• Code plus simple : Un seul appel de méthode

// Ajoutez la dépendance : commons-validator
import org.apache.commons.validator.routines.EmailValidator;
EmailValidator validator = EmailValidator.getInstance();
boolean isValid = validator.isValid("user@example.com"); // true

Conseils pro rapides

1. Échappez correctement en Java : Utilisez des doubles barres obliques inverses dans les chaînes regex : \. et non .

2. Ajoutez l'insensibilité à la casse : Utilisez Pattern.compile(regex, Pattern.CASE_INSENSITIVE)

3. Autorisez l'adressage plus : Incluez + dans la classe de caractères de la partie locale : [a-zA-Z0-9._%+-]

4. Validez au-delà du regex : Le regex vérifie uniquement le format. Associez toujours à une vérification d'e-mail réelle ou à des vérifications DNS.

5. Compilez une fois, réutilisez : Utilisez Pattern.compile() comme champ statique pour éviter de recompiler à chaque appel.

Cas d'utilisation courants

• Formulaires de connexion et d'inscription : Validez les saisies e-mail en frontend et backend

• Nettoyage de données : Filtrez les enregistrements e-mail invalides dans les jeux de données

• Validation d'API : Vérifiez les formats d'e-mail avant de traiter les requêtes POST

• Systèmes CRM : Imposez un format d'e-mail correct dans les fiches contact

Associez-le à ces outils

• Testeur regex Java : Testez et déboguez des patterns regex personnalisés en Java.

• Validateur regex Java de mot de passe : Validez des politiques de mots de passe forts en Java.

• Validateur regex Java d'UUID : Vérifiez la conformité du format UUID dans les applications Java.

• Validateur Java de numéros de téléphone : Validez les numéros de téléphone internationaux en Java.

• Validateur Java d'URL : Vérifiez que les URL correspondent au format attendu dans les applications Java.