Перейти к основному содержимому

Проверка электронной почты в Java

· 8 мин. чтения

1. Обзор​

В этом руководстве мы узнаем, как проверять адреса электронной почты в Java с помощью регулярных выражений .

2. Проверка электронной почты в Java​

Проверка электронной почты требуется почти в каждом приложении, в котором есть регистрация пользователя.

Адрес электронной почты делится на три основные части: локальная часть, символ @ и домен. Например, если « username@domain.com » — это электронная почта, то:

  • локальная часть = имя пользователя
  • знак равно
  • домен = домен.com

Для проверки адреса электронной почты с помощью методов манипулирования строками может потребоваться много усилий, поскольку обычно нам нужно подсчитывать и проверять все типы и длины символов. Но в Java с использованием регулярных выражений это может быть намного проще.

Как известно, регулярное выражение — это последовательность символов, соответствующая шаблону. В следующих разделах мы увидим, как можно выполнить проверку электронной почты с помощью нескольких различных методов регулярных выражений.

3. Простая проверка регулярного выражения​

Самое простое регулярное выражение для проверки адреса электронной почты — ^(.+)@(\S+) $ .

Он проверяет только наличие символа @ в адресе электронной почты. Если он присутствует, то результат проверки возвращает true, в противном случае — false . Однако это регулярное выражение не проверяет локальную часть и домен электронной почты.

Например, в соответствии с этим регулярным выражением, username@domain.com пройдет проверку, но username#domain.com не пройдет проверку.

Давайте определим простой вспомогательный метод, соответствующий шаблону регулярного выражения:

public static boolean patternMatches(String emailAddress, String regexPattern) {
    return Pattern.compile(regexPattern)
      .matcher(emailAddress)
      .matches();
}

Мы также напишем код для проверки адреса электронной почты, используя это регулярное выражение:

@Test
public void testUsingSimpleRegex() {
    emailAddress = "username@domain.com";
    regexPattern = "^(.+)@(\\S+)$";
    assertTrue(EmailValidation.patternMatches(emailAddress, regexPattern));
}

Отсутствие символа @ в адресе электронной почты также не пройдет проверку.

4. Строгая проверка регулярного выражения​

Теперь давайте напишем более строгое регулярное выражение, которое будет проверять локальную часть, а также доменную часть письма:

^(?=.{1,64}@)[A-Za-z0-9_-]+(\\.[A-Za-z0-9_-]+)*@[^-][A-Za- z0-9-]+(\\.[A-Za-z0-9-]+)*(\\.[A-Za-z]{2,})$

При использовании этого регулярного выражения в локальной части адреса электронной почты накладываются следующие ограничения:

  • Он допускает числовые значения от 0 до 9.
  • Допускаются как прописные, так и строчные буквы от a до z.
  • Допустимы подчеркивание «_», дефис «-» и точка «».
  • Точка не допускается в начале и в конце локальной части.
  • Последовательные точки не допускаются.
  • Для локальной части разрешено не более 64 символов.

Ограничения для части домена в этом регулярном выражении включают:

  • Он допускает числовые значения от 0 до 9.
  • Мы допускаем как прописные, так и строчные буквы от a до z.
  • Дефис «-» и точка «.» не допускаются в начале и в конце доменной части.
  • Нет последовательных точек.

Мы также напишем код для проверки этого регулярного выражения:

@Test
public void testUsingStrictRegex() {
    emailAddress = "username@domain.com";
    regexPattern = "^(?=.{1,64}@)[A-Za-z0-9_-]+(\\.[A-Za-z0-9_-]+)*@" 
        + "[^-][A-Za-z0-9-]+(\\.[A-Za-z0-9-]+)*(\\.[A-Za-z]{2,})$";
    assertTrue(EmailValidation.patternMatches(emailAddress, regexPattern));
}

Таким образом, некоторые из адресов электронной почты, которые будут действительны с помощью этого метода проверки электронной почты:

  • имя пользователя@домен.com
  • имя_пользователя@домен.com
  • имя пользователя@домен.com
  • имя пользователя@домен.co.in
  • имя_пользователя@домен.com

Вот краткий список некоторых адресов электронной почты, которые будут недействительны при этой проверке электронной почты:

  • имя пользователя.@домен.com
  • .имя.пользователя@домен.com
  • имя пользователя@домен.com.
  • имя пользователя@.com

5. Регулярное выражение для проверки нелатинских символов или символов Юникода. Электронная почта​

Регулярное выражение, которое мы только что видели в предыдущем разделе, будет хорошо работать для адресов электронной почты, написанных на английском языке, но не будет работать для адресов электронной почты не на латинице.

Итак, мы напишем регулярное выражение, которое мы также можем использовать для проверки символов Юникода:

^(?=.{1,64}@)[\\p{L}0-9_-]+(\\.[\\p{L}0-9_-]+)*@[^-][ \\p{L}0-9-]+(\\.[\\p{L}0-9-]+)*(\\.[\\p{L}]{2,})$

Мы можем использовать это регулярное выражение для проверки Unicode или нелатинских адресов электронной почты для поддержки всех языков.

Как мы видим, это регулярное выражение похоже на строгое регулярное выражение, которое мы построили в предыдущем разделе, за исключением того, что мы заменили часть « A-Za-Z » на « \\p{L}» . Это необходимо для включения поддержки символов Unicode.

Давайте проверим это регулярное выражение, написав тест:

@Test
public void testUsingUnicodeRegex() {
    emailAddress = "用户名@领域.电脑";
    regexPattern = "^(?=.{1,64}@)[\\p{L}0-9_-]+(\\.[\\p{L}0-9_-]+)*@" 
        + "[^-][\\p{L}0-9-]+(\\.[\\p{L}0-9-]+)*(\\.[\\p{L}]{2,})$";
    assertTrue(EmailValidation.patternMatches(emailAddress, regexPattern));
}

Это регулярное выражение не только представляет более строгий подход к проверке адресов электронной почты, но также поддерживает нелатинские символы.

6. Регулярное выражение RFC 5322 для проверки электронной почты​

Вместо того, чтобы писать собственное регулярное выражение для проверки адресов электронной почты, мы можем использовать его, предусмотренное стандартами RFC.

RFC 5322 , который является обновленной версией RFC 822 , предоставляет регулярное выражение для проверки электронной почты.

Давайте проверим это:

^[a-zA-Z0-9_!#$%&'*+/=?{|}~^.-] +@ [a-zA-Z0-9.-]+$`

Как мы видим, это очень простое регулярное выражение, которое допускает использование всех символов в электронном письме.

Однако он не позволяет использовать символ вертикальной черты (|) и одинарную кавычку ('), так как они представляют потенциальный риск внедрения кода SQL при передаче с клиентского сайта на сервер.

Давайте напишем код для проверки электронной почты с помощью этого регулярного выражения:

@Test
public void testUsingRFC5322Regex() {
    emailAddress = "username@domain.com";
    regexPattern = "^[a-zA-Z0-9_!#$%&'*+/=?`{|}~^.-]+@[a-zA-Z0-9.-]+$";
    assertTrue(EmailValidation.patternMatches(emailAddress, regexPattern));
}

7. Регулярное выражение для проверки символов в домене верхнего уровня​

Мы написали регулярное выражение для проверки локальной и доменной частей адреса электронной почты. Теперь мы также напишем регулярное выражение, которое проверяет домен верхнего уровня электронной почты.

Приведенное ниже регулярное выражение проверяет доменную часть верхнего уровня адреса электронной почты:

^[\\w!#$%&'*+/=?{|}~^-]+(?:\.[\w!#$%&'*+/=?`{|} ~^-]+)*@(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,6}$`

Это регулярное выражение в основном проверяет, имеет ли адрес электронной почты только одну точку, и что в домене верхнего уровня присутствует минимум два и максимум шесть символов.

Мы также напишем код для проверки адреса электронной почты с помощью этого регулярного выражения:

@Test
public void testTopLevelDomain() {
    emailAddress = "username@domain.com";
    regexPattern = "^[\\w!#$%&'*+/=?`{|}~^-]+(?:\\.[\\w!#$%&'*+/=?`{|}~^-]+)*" 
        + "@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,6}$";
    assertTrue(EmailValidation.patternMatches(emailAddress, regexPattern));
}

8 . Регулярное выражение для ограничения последовательных, конечных и начальных точек​

Теперь давайте напишем регулярное выражение, которое ограничит использование точек в адресах электронной почты:

^[a-zA-Z0-9_!#$%&'*+/=?{|}~^-]+(?:\.[a-zA-Z0-9_!#$%&'* +/=?`{|}~^-]+)@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)$`

Приведенное выше регулярное выражение используется для последовательного ограничения начальных и конечных точек. Таким образом, электронное письмо может содержать более одной точки, но не подряд в локальной и доменной частях.

Давайте посмотрим на код:

@Test
public void testRestrictDots() {
    emailAddress = "username@domain.com";
    regexPattern = "^[a-zA-Z0-9_!#$%&'*+/=?`{|}~^-]+(?:\\.[a-zA-Z0-9_!#$%&'*+/=?`{|}~^-]+)*@" 
        + "[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*$";
    assertTrue(EmailValidation.patternMatches(emailAddress, regexPattern));
}

9. Регулярное выражение проверки OWASP​

Это регулярное выражение предоставляется репозиторием регулярных выражений проверки OWASP для проверки проверки электронной почты:

^[a-zA-Z0-9_+&*-] + (?:\\.[a-zA-Z0-9_+&*-] + )*@(?:[a-zA-Z0-9- ]+\\.) + [a-zA-Z]{2, 7}

Это регулярное выражение также поддерживает большинство проверок в стандартной структуре электронной почты.

Давайте подтвердим адрес электронной почты, используя приведенный ниже код:

@Test
public void testOwaspValidation() {
    emailAddress = "username@domain.com";
    regexPattern = "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";
    assertTrue(EmailValidation.patternMatches(emailAddress, regexPattern));
}

10. Особый случай Gmail для электронных писем​

Есть один особый случай, который применяется только к домену Gmail: это разрешение использовать символ + символ в локальной части электронной почты. Для домена Gmail два адреса электронной почты username+something@gmail.com и username@gmail.com совпадают.

Кроме того, username@gmail.com похож на user+name@gmail.com.

Мы должны реализовать немного другое регулярное выражение, которое также будет проходить проверку электронной почты для этого особого случая:

^(?=.{1,64}@)[A-Za-z0-9_-+]+(\\.[A-Za-z0-9_-+]+)*@[^-][A- Za-z0-9-+]+(\\.[A-Za-z0-9-+]+)*(\\.[A-Za-z]{2,})$

Давайте напишем пример для проверки этого варианта использования:

@Test
public void testGmailSpecialCase() {
    emailAddress = "username+something@domain.com";
    regexPattern = "^(?=.{1,64}@)[A-Za-z0-9\\+_-]+(\\.[A-Za-z0-9\\+_-]+)*@" 
        + "[^-][A-Za-z0-9\\+-]+(\\.[A-Za-z0-9\\+-]+)*(\\.[A-Za-z]{2,})$";
    assertTrue(EmailValidation.patternMatches(emailAddress, regexPattern));
}

11. Apache Commons Validator для электронной почты​

Apache Commons Validator — это пакет проверки, который содержит стандартные правила проверки. Таким образом, импортировав этот пакет, мы можем применить проверку электронной почты.

Мы можем использовать класс EmailValidator для проверки электронной почты, который использует стандарты RFC 822. Этот валидатор содержит смесь пользовательского кода и регулярных выражений для проверки электронной почты. Он поддерживает не только специальные символы, но и обсуждаемые нами символы Unicode.

Давайте добавим зависимость commons-validator в наш проект:

<dependency>
    <groupId>commons-validator</groupId>
    <artifactId>commons-validator</artifactId>
    <version>${validator.version}</version>
</dependency>

Теперь мы можем проверить адреса электронной почты, используя следующий код:

@Test
public void testUsingEmailValidator() {
    emailAddress = "username@domain.com";
    assertTrue(EmailValidator.getInstance()
      .isValid(emailAddress));
}

12. Какое регулярное выражение следует использовать?​

В этой статье мы рассмотрели множество решений, использующих регулярное выражение для проверки адреса электронной почты. Очевидно, что определение того, какое решение мы должны использовать, зависит от того, насколько строгой должна быть наша проверка, и от наших точных требований.

Например, мы можем использовать простое регулярное выражение из раздела 3, если нам просто нужно простое регулярное выражение для проверки наличия символа @ в электронном письме. Однако для более подробной проверки мы можем выбрать более строгое регулярное выражение из раздела 6 на основе стандарта RFC5322.

Наконец, если мы имеем дело с символами Unicode в электронном письме, мы можем использовать решение с регулярными выражениями, представленное в разделе 5.

13. Заключение​

В этой статье мы узнали о различных способах проверки адресов электронной почты в Java с помощью регулярных выражений.

Полный код для этой статьи доступен на GitHub .