E-Mail-Regex-Java-Validator

Was ist E-Mail-Regex in Java?

In Java werden E-Mail-Regex-Muster verwendet, um zu prüfen, ob eine Benutzereingabe einem gültigen E-Mail-Format entspricht. Dazu gehört das Vorhandensein eines lokalen Teils, eines "@"-Symbols und einer Domain mit gültiger Top-Level-Domain.

Typische E-Mail-Validierungen prüfen auf:

• Alphanumerische Zeichen

• Punkte, Bindestriche und Unterstriche in Benutzernamen

• Eine gültige Domain mit mindestens einem . und 2+ Zeichen in der Erweiterung

Gültige vs. ungültige E-Mail-Adressen

Gültig:

• username@domain.com

• user.name@domain.com

• user-name@domain.com

• username@domain.co.in

• user+tag@gmail.com

Ungültig:

• username.@domain.com (abschließender Punkt)

• .user.name@domain.com (führender Punkt)

• user..name@domain.com (aufeinanderfolgende Punkte)

• username@.com (kein Domain-Name)

Vergleichstabelle für E-Mail-Regex-Muster

Wählen Sie das richtige Muster für Ihren Anwendungsfall:

Produktionsreife Java-Code-Beispiele

Beispiel 1: Standard-E-Mail-Validierung

Testen Sie dies im Java-Regex-Tester

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
}

}

Beispiel 2: Strenge Validierung (keine aufeinanderfolgenden Punkte, Längenbeschränkungen)

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 (aufeinanderfolgende Punkte)
        ".user@domain.com",          // false (führender Punkt)
        "username.@domain.com"       // false (abschließender Punkt)
    };
    for (String email : emails) {
        System.out.println(email + ": " + STRICT_PATTERN.matcher(email).matches());
    }
}

}

Beispiel 3: Groß- und Kleinschreibung ignorieren

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
}
}

Beispiel 4: Unicode / Internationale E-Mail-Adressen

Um E-Mails mit nicht-lateinischen Zeichen (Chinesisch, Kyrillisch, Arabisch) zu validieren, ersetzen Sie [A-Za-z] durch \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,})$"
);
// ...
}

Beispiel 5: Wiederverwendbare Validierungs-Utility-Methode

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();
}

}

So funktioniert es

1. Fügen Sie Ihr Regex-Muster und die Test-E-Mail in den Validator oben ein.

2. Es verwendet Java's Pattern.compile() und Matcher.matches() im Hintergrund.

3. Sehen Sie sofort, ob Ihr regex die angegebene E-Mail-Adresse korrekt trifft.

Anatomie einer E-Mail-Adresse

Jede E-Mail-Adresse hat drei Teile:

• Lokaler Teil: Der Benutzername vor dem @ (z. B. emma)

• @-Symbol: Der Trenner

• Domain-Teil: Der Anbieter nach dem @ (z. B. qodex.ai)

Zu berücksichtigende Validierungsregeln:

• Erlaubte Zeichen: Buchstaben, Zahlen, . _ - + % im lokalen Teil

• Punktbeschränkungen: Keine führenden, abschließenden oder aufeinanderfolgenden Punkte in beiden Teilen

• Längenbeschränkungen: Lokaler Teil max. 64 Zeichen, Domain max. 255 Zeichen

• TLD-Format: 2-6 alphabetische Zeichen (z. B. .com, .museum)

• Plus-Adressierung: Gmail-ähnliche Aliase wie user+tag@gmail.com sollten erlaubt sein

Im E-Mail-Regex verwendete Metazeichen

• .: Passt auf beliebiges Zeichen außer Zeilenumbruch

• ^: Verankert am Anfang des Strings

• $: Verankert am Ende des Strings

• []: Zeichenklasse

• +: Eines oder mehr Wiederholungen

• *: Null oder mehr Wiederholungen

• {n,}: Mindestens n Wiederholungen

• (): Gruppiert regex-Teile

• \: Escapt Sonderzeichen

Einschränkungen von RFC 5322-E-Mail-Regex

RFC 5322-konforme regex-Muster können Probleme verursachen:

• Zu permissiv: Können Zeichen erlauben, die für Ihre nachgelagerten Systeme unsicher sind

• Sicherheitsrisiken: Einige Muster schließen absichtlich das Pipe-Zeichen (|) und das einfache Anführungszeichen (') aus, um SQL-Injection zu verhindern

• Komplexität: RFC-konforme Muster können Hunderte von Zeichen lang sein

Für die meisten Anwendungen ist das strenge oder OWASP-Muster aus der obigen Tabelle die beste Balance aus Sicherheit und Abdeckung.

Warum Apache Commons Validator verwenden?

Für produktive Java-Anwendungen sollten Sie Apache Commons Validator als Alternative zu benutzerdefinierten regex erwägen:

• Standardkonform: Folgt RFC 822-Regeln, behandelt Edge-Cases automatisch

• Unicode-Unterstützung: Behandelt internationale E-Mail-Adressen direkt

• Gepflegt: Wird aktiv von der Open-Source-Community aktualisiert

• Einfacherer Code: Ein Methodenaufruf statt komplexer regex-Muster

// Abhängigkeit hinzufügen: commons-validator
import org.apache.commons.validator.routines.EmailValidator;
EmailValidator validator = EmailValidator.getInstance();
boolean isValid = validator.isValid("user@example.com"); // true

Schnelle Profi-Tipps

1. In Java korrekt escapen: Verwenden Sie doppelte Backslashes in regex-Strings: \. statt .

2. Groß-/Kleinschreibung ignorieren: Verwenden Sie Pattern.compile(regex, Pattern.CASE_INSENSITIVE)

3. Plus-Adressierung erlauben: Fügen Sie + in die Zeichenklasse des lokalen Teils ein: [a-zA-Z0-9._%+-]

4. Über regex hinaus validieren: Regex prüft nur das Format. Kombinieren Sie es immer mit echter E-Mail-Verifizierung oder Domain-DNS-Prüfungen.

5. Einmal kompilieren, wiederverwenden: Verwenden Sie Pattern.compile() als statisches Feld, um ein erneutes Kompilieren bei jedem Aufruf zu vermeiden.

Häufige Anwendungsfälle

• Login- und Anmeldeformulare: E-Mail-Eingabe im Frontend und Backend validieren

• Datenbereinigung: Ungültige E-Mail-Datensätze aus Datensätzen herausfiltern

• API-Validierung: E-Mail-Formate vor der Verarbeitung von POST-Anfragen prüfen

• CRM-Systeme: Korrektes E-Mail-Format in Kontaktdatensätzen erzwingen

Kombinieren Sie dieses Tool mit

• Java-Regex-Tester: Benutzerdefinierte regex-Muster in Java sofort testen und debuggen.

• Java-Passwort-Regex-Validator: Starke Passwortrichtlinien in Java validieren.

• Java-UUID-Regex-Validator: UUID-Format-Konformität in Java-Anwendungen prüfen.

• Java-Telefonnummer-Validator: Internationale Telefonnummern in Java validieren.

• Java-URL-Validator: Sicherstellen, dass URLs dem erwarteten Format in Java-basierten Apps entsprechen.