5 Ways to Implement Email Validation in Java

Ensuring email addresses are valid is a key step for data integrity in many Java applications. You'll find five distinct implementation methods here, each with working code. We'll examine the shortcomings of traditional approaches and then see how Abstract API effectively addresses these common validation challenges.

How to Implement Email Validation in Java

Here are four common ways to validate email addresses in Java. Each method approaches the problem differently, from simple pattern matches to network-level checks for domain validity.

Regular Expressions with java.util.regex.Pattern

This method uses a regular expression (regex) to check email syntax. The java.util.regex.Pattern class compiles the expression once for repeated use, which is efficient. The matcher method then compares the input string against this compiled pattern to determine if it is a valid format.

private static final Pattern EMAIL = Pattern.compile("^[A-Za-z0-9_+&*-]+(?:\\.[A-Za-z0-9_+&*-]+)*@(?:[A-Za-z0-9-]+\\.)+[A-Za-z]{2,7}$");
boolean ok = EMAIL.matcher(candidate).matches();

javax.mail.internet.InternetAddress Class

This approach leverages the parser built into the JavaMail API. The code attempts to create a new InternetAddress object from the candidate string and then calls its validate method. If the string does not conform to syntax rules, the method throws an AddressException, which signals an invalid email.

boolean ok;
try {
    new InternetAddress(candidate).validate();
    ok = true;
} catch (AddressException ex) {
    ok = false;
}

Apache Commons Validator

This method relies on the dedicated EmailValidator class from the Apache Commons Validator library. After you add the dependency, you can get a validator instance. The isValid method then returns a simple boolean result. The validator supports Internationalized Domain Names (IDN) and has configurable flags for local domains.

EmailValidator v = EmailValidator.getInstance(false, false);
boolean ok = v.isValid(candidate);

Syntax Check with DNS MX Lookup

This technique combines a syntax check with a network-level verification. After an initial pattern check confirms the email format is correct, the code performs a DNS lookup. It queries for a Mail Exchange (MX) record associated with the email's domain. The presence of an MX record indicates the domain is configured to accept mail.

String domain = candidate.substring(candidate.indexOf('@') + 1);
DirContext ctx = new InitialDirContext();
Attributes mx = ctx.getAttributes("dns:/" + domain, new String[]{"MX"});
boolean ok = mx.size() > 0;

Challenges of Email Validation in Java

Despite these available methods, robust email validation in Java presents significant hurdles. The official standards are far more complex than most libraries can handle, which leads to common implementation pitfalls.

• Regular expressions and the InternetAddress class struggle with RFC grammar. They cannot handle complex cases like quoted strings, comments, or UTF-8 local parts. This results in validators that are either too complex or functionally incomplete for modern email addresses.
• International emails with Unicode characters often cause failures. Legacy code that uses InternetAddress or third-party validators like Apache Commons Validator may not properly support the required punycode translation for domains or SMTPUTF8 for the local part.
• Syntax checks with Pattern or InternetAddress ignore deliverability. An address can have a valid format but resolve to a domain with no mail server. This creates a risk of silent bounces that simple validation methods do not prevent.
• Common regex patterns often reject valid edge cases like domains with hyphens or case-sensitive local parts. Loosened patterns may accept invalid formats. This creates a constant cycle of false negatives and false positives for the java.util.regex.Pattern method.