Validação de E-mail em Java: Verificando Formatos com Expressões Regulares

Introdução

Neste laboratório, você aprenderá como validar se uma determinada string corresponde a um formato de e-mail padrão em Java usando expressões regulares (regex). Definiremos um padrão regex adequado, utilizaremos o método Pattern.matches() para validação e testaremos nossa implementação com vários endereços de e-mail válidos e inválidos para garantir que funcione corretamente. Este exercício prático fornecerá experiência com as capacidades de regex do Java para correspondência de padrões de strings.

Definir o Padrão Regex para E-mail

Nesta etapa, começaremos definindo o padrão de expressão regular que usaremos para validar endereços de e-mail. Expressões regulares, frequentemente abreviadas para "regex" ou "regexp", são sequências de caracteres que definem um padrão de busca. Elas são extremamente poderosas para correspondência de padrões e manipulação de strings.

Para validação de e-mail, um padrão regex nos ajuda a verificar se uma determinada string segue o formato padrão de um endereço de e-mail (por exemplo, nome_de_usuario@dominio.com). Embora uma regex perfeita para todos os endereços de e-mail válidos possíveis seja muito complexa, podemos definir um padrão que cubra os formatos mais comuns e válidos.

Criaremos um novo arquivo Java para conter nosso código.

Abra o WebIDE, caso ainda não esteja aberto. Você deve estar no diretório ~/project por padrão.
No Explorador de Arquivos à esquerda, clique com o botão direito no espaço vazio e selecione "Novo Arquivo". Nomeie o arquivo EmailValidator.java.
Abra o arquivo EmailValidator.java no editor, clicando nele no Explorador de Arquivos.
Agora, vamos adicionar a estrutura básica da nossa classe Java e definir o padrão regex. Copie e cole o seguinte código no arquivo EmailValidator.java:
```
import java.util.regex.Pattern;

public class EmailValidator {

    // Email regex pattern
    private static final String EMAIL_REGEX =
            "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";

    public static void main(String[] args) {
        // We will add code here in the next steps
    }
}
```
Vamos dar uma olhada brevemente nas novas partes:
- import java.util.regex.Pattern;: Esta linha importa a classe Pattern, que faz parte do suporte embutido do Java para expressões regulares.
- private static final String EMAIL_REGEX = "...";: Esta linha declara uma variável constante chamada EMAIL_REGEX e atribui nosso padrão de expressão regular a ela.
  - ^: Corresponde ao início da string.
  - [a-zA-Z0-9_+&*-]+: Corresponde a um ou mais caracteres alfanuméricos ou _, +, &, *, -. Isso é para a parte do nome de usuário.
  - (?:\\.[a-zA-Z0-9_+&*-]+)*: Corresponde a zero ou mais ocorrências de um ponto seguido por mais caracteres de nome de usuário. Isso permite pontos no nome de usuário (por exemplo, primeiro.ultimo).
  - @: Corresponde ao símbolo literal "@".
  - (?:[a-zA-Z0-9-]+\\.)+: Corresponde a uma ou mais ocorrências de caracteres alfanuméricos ou - seguidos por um ponto. Isso é para o nome de domínio (por exemplo, dominio.).
  - [a-zA-Z]{2,7}: Corresponde a 2 a 7 caracteres alfabéticos para o domínio de nível superior (por exemplo, com, org, códigos de país).
  - $: Corresponde ao final da string.
Não se preocupe se o padrão regex parecer complicado. Entender cada detalhe de padrões regex complexos leva tempo e prática. Por enquanto, concentre-se no fato de que esta string define a regra para a aparência de um endereço de e-mail válido.
Salve o arquivo EmailValidator.java (Ctrl+S ou Cmd+S).

Você criou com sucesso o arquivo Java e definiu o padrão de expressão regular para validação de e-mail. Na próxima etapa, usaremos este padrão para validar endereços de e-mail reais.

Usar Pattern.matches() para Validação de E-mail

Nesta etapa, aprenderemos como usar o método Pattern.matches() em Java para verificar se uma determinada string corresponde ao nosso padrão regex de e-mail definido. O método Pattern.matches(regex, input) é uma maneira conveniente de realizar uma correspondência simples de uma string de entrada inteira em relação a uma expressão regular. Ele retorna true se a string de entrada inteira corresponder à regex e false caso contrário.

Adicionaremos um novo método à nossa classe EmailValidator para realizar essa validação.

Abra o arquivo EmailValidator.java no editor WebIDE, caso ainda não esteja aberto.
Adicione o seguinte método dentro da classe EmailValidator, mas fora do método main:
```
public static boolean isValidEmail(String email) {
    return Pattern.matches(EMAIL_REGEX, email);
}
```
Vamos analisar este novo método:
- public static boolean isValidEmail(String email): Isso declara um novo método chamado isValidEmail.
  - public: Significa que este método pode ser acessado de fora da classe.
  - static: Significa que este método pertence à própria classe EmailValidator, não a um objeto específico da classe. Podemos chamá-lo diretamente usando o nome da classe (por exemplo, EmailValidator.isValidEmail(...)).
  - boolean: Indica que este método retornará um valor booleano (true ou false).
  - (String email): Especifica que o método recebe um argumento, uma String chamada email, que é o endereço de e-mail que queremos validar.
- return Pattern.matches(EMAIL_REGEX, email);: Este é o núcleo do método. Ele chama o método Pattern.matches(), passando nosso EMAIL_REGEX e a string de entrada email. O resultado desta correspondência (true ou false) é então retornado pelo nosso método isValidEmail.
Agora, vamos modificar o método main para usar nosso novo método isValidEmail. Substitua o método main existente pelo seguinte código:
```
public static void main(String[] args) {
    String testEmail = "test.email@example.com";
    boolean isValid = isValidEmail(testEmail);

    if (isValid) {
        System.out.println(testEmail + " is a valid email address.");
    } else {
        System.out.println(testEmail + " is not a valid email address.");
    }
}
```
Neste método main atualizado:
- String testEmail = "test.email@example.com";: Definimos um endereço de e-mail de amostra para testar.
- boolean isValid = isValidEmail(testEmail);: Chamamos nosso método isValidEmail com o testEmail e armazenamos o valor booleano retornado na variável isValid.
- O bloco if e else verifica o valor de isValid e imprime uma mensagem indicando se o e-mail é válido ou não.
Salve o arquivo EmailValidator.java (Ctrl+S ou Cmd+S).
Agora, vamos compilar nosso programa atualizado. Abra o Terminal na parte inferior do WebIDE e certifique-se de estar no diretório ~/project. Execute o seguinte comando:
```
javac EmailValidator.java
```
Se não houver erros, a compilação foi bem-sucedida.
Finalmente, execute o programa compilado usando o comando java:
```
java EmailValidator
```
Você deve ver a saída indicando se o e-mail de teste é válido com base em nosso padrão regex.
```
test.email@example.com is a valid email address.
```

Você usou com sucesso o método Pattern.matches() para validar um endereço de e-mail usando seu padrão regex definido. Na próxima etapa, testaremos com diferentes endereços de e-mail válidos e inválidos.

Testar com E-mails Válidos e Inválidos

Nesta etapa final, testaremos nosso EmailValidator com alguns exemplos de endereços de e-mail válidos e inválidos para ver como nosso padrão regex e o método Pattern.matches() os tratam. Isso nos ajudará a entender o comportamento de nossa lógica de validação.

Abra o arquivo EmailValidator.java no editor WebIDE.

Modifique o método main para testar vários endereços de e-mail. Substitua o método main atual pelo seguinte código:

public static void main(String[] args) {
    String[] testEmails = {
        "test.email@example.com",       // Valid
        "another_test+alias@sub.domain.co.uk", // Valid
        "invalid-email",                // Invalid (missing @)
        "invalid@domain",               // Invalid (missing top-level domain)
        "invalid@domain.",              // Invalid (missing top-level domain)
        "invalid@domain.c",             // Invalid (top-level domain too short)
        "invalid@domain.abcdefgh",      // Invalid (top-level domain too long)
        "@domain.com",                  // Invalid (missing username)
        "test@.com"                     // Invalid (missing domain name)
    };

    for (String email : testEmails) {
        boolean isValid = isValidEmail(email);

        if (isValid) {
            System.out.println(email + " is a valid email address.");
        } else {
            System.out.println(email + " is not a valid email address.");
        }
    }
}

Neste método main atualizado:

Criamos um array de strings chamado testEmails contendo vários endereços de e-mail, incluindo os válidos e os intencionalmente inválidos.
Usamos um loop for para iterar por cada endereço de e-mail no array testEmails.
Dentro do loop, para cada email, chamamos nosso método isValidEmail e imprimimos o resultado, assim como fizemos na etapa anterior.

Salve o arquivo EmailValidator.java (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
```
javac EmailValidator.java
```
Certifique-se de que não haja erros de compilação.

Execute o programa compilado:

java EmailValidator

Observe a saída. Você deve ver uma linha para cada endereço de e-mail no array testEmails, indicando se nosso validador o considera válido ou não com base no padrão regex.

test.email@example.com is a valid email address.
another_test+alias@sub.domain.co.uk is a valid email address.
invalid-email is not a valid email address.
invalid@domain is not a valid email address.
invalid@domain. is not a valid email address.
invalid@domain.c is not a valid email address.
invalid@domain.abcdefgh is not a valid email address.
@domain.com is not a valid email address.
test@.com is not a valid email address.

Ao testar com diferentes entradas, você pode ver como o padrão regex e o método Pattern.matches() trabalham juntos para validar endereços de e-mail. Lembre-se de que, embora esta regex cubra muitos casos comuns, validar todos os formatos de e-mail possíveis de acordo com padrões rigorosos pode ser muito mais complexo.

Você implementou e testou com sucesso um mecanismo básico de validação de e-mail usando os recursos de expressão regular do Java.

Resumo

Neste laboratório, começamos configurando nosso ambiente Java e criando um novo arquivo EmailValidator.java. Em seguida, definimos um padrão de expressão regular (EMAIL_REGEX) especificamente projetado para validar endereços de e-mail. Este padrão, armazenado como uma string constante, utiliza a classe java.util.regex.Pattern do Java para habilitar recursos poderosos de correspondência de strings. Esta etapa inicial estabelece a base para a implementação da lógica de validação de e-mail nas etapas subsequentes.

Como Verificar se uma String Corresponde ao Formato de um E-mail em Java

Introdução

Definir o Padrão Regex para E-mail

Usar Pattern.matches() para Validação de E-mail

Testar com E-mails Válidos e Inválidos

Resumo