Como Verificar se uma String Corresponde ao Formato de URL em Java - Validação com Regex

Introdução

Neste laboratório, você aprenderá como verificar se uma determinada string corresponde a um formato de URL em Java usando expressões regulares (regex). Definiremos um padrão de regex especificamente projetado para URLs, utilizaremos o método Pattern.matches() para testar strings em relação a este padrão e exploraremos como validar esquemas de URL comuns. Este exercício prático irá guiá-lo através das etapas práticas de implementação da validação de URL em suas aplicações Java.

Definir Padrão de Regex para URL

Nesta etapa, aprenderemos como definir um padrão de expressão regular em Java para corresponder a URLs. 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 validar URLs, um padrão de regex nos ajuda a verificar se uma determinada string segue a estrutura padrão de uma URL (como http://www.example.com ou https://example.org/path).

Vamos criar um novo arquivo Java para trabalhar com regex.

Abra o WebIDE. No Explorador de Arquivos à esquerda, certifique-se de estar no diretório ~/project.
Clique com o botão direito no espaço vazio dentro do diretório ~/project e selecione "Novo Arquivo".
Nomeie o novo arquivo UrlValidator.java e pressione Enter.
O arquivo UrlValidator.java deve abrir no Editor de Código.
Copie e cole o seguinte código Java no editor:
```
import java.util.regex.Pattern;

public class UrlValidator {

    public static void main(String[] args) {
        // Define a simple regex pattern for a URL
        String urlRegex = "^(http|https)://[^\\s/$.?#].[^\\s]*$";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(urlRegex);

        System.out.println("URL Regex Pattern Defined.");
    }
}
```
Vamos detalhar as novas partes deste código:
- import java.util.regex.Pattern;: Esta linha importa a classe Pattern, que faz parte do suporte embutido do Java para expressões regulares.
- String urlRegex = "^(http|https)://[^\\s/$.?#].[^\\s]*$";: Esta linha define uma variável String chamada urlRegex e atribui a ela nosso padrão de expressão regular.
  - ^: Corresponde ao início da string.
  - (http|https): Corresponde a "http" ou "https".
  - ://: Corresponde aos caracteres literais "://".
  - [^\\s/$.?#]: Corresponde a qualquer caractere que NÃO seja um caractere de espaço em branco (\\s), uma barra (/), um cifrão ($), um ponto (.), um ponto de interrogação (?) ou um símbolo de hash (#). Esta é uma maneira simplificada de corresponder à parte do nome de domínio.
  - .: Corresponde a qualquer caractere (exceto nova linha).
  - [^\\s]*: Corresponde a zero ou mais caracteres que NÃO são espaços em branco. Esta é uma maneira simplificada de corresponder ao restante do caminho e consulta da URL.
  - $: Corresponde ao final da string.
  - Observe as barras invertidas duplas (\\) antes de s. Em strings Java, uma única barra invertida é um caractere de escape, então precisamos de \\ para representar uma barra invertida literal no padrão regex.
- Pattern pattern = Pattern.compile(urlRegex);: Esta linha compila a string regex em um objeto Pattern. Compilar o padrão é mais eficiente se você planeja usar o mesmo padrão várias vezes.
- System.out.println("URL Regex Pattern Defined.");: Esta linha simplesmente imprime uma mensagem no console para indicar que o padrão foi definido.
Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, vamos compilar este programa Java. Abra o Terminal na parte inferior do WebIDE. Certifique-se de estar no diretório ~/project.
Compile o código usando o comando javac:
```
javac UrlValidator.java
```
Se não houver erros, o comando será concluído sem saída. Um arquivo UrlValidator.class será criado no diretório ~/project.
Execute o programa compilado usando o comando java:
```
java UrlValidator
```
Você deve ver a saída:
```
URL Regex Pattern Defined.
```

Você definiu e compilou com sucesso um programa Java que inclui um padrão regex básico para URLs. Na próxima etapa, usaremos este padrão para testar se diferentes strings são URLs válidas.

Testar URL com Pattern.matches()

Na etapa anterior, definimos um padrão de regex para URLs e o compilamos em um objeto Pattern. Agora, vamos usar este padrão para verificar se diferentes strings são URLs válidas usando o método Pattern.matches().

O método Pattern.matches(regex, input) é uma maneira conveniente de verificar se uma string de entrada inteira corresponde a uma determinada expressão regular. Ele compila a regex e compara a entrada com ela em uma única etapa.

Vamos modificar nosso arquivo UrlValidator.java para testar algumas URLs de exemplo.

Abra o arquivo UrlValidator.java no editor WebIDE, se ele ainda não estiver aberto.

Modifique o método main para incluir o seguinte código. Você adicionará este código após a linha Pattern pattern = Pattern.compile(urlRegex);.

import java.util.regex.Pattern;

public class UrlValidator {

    public static void main(String[] args) {
        // Define a simple regex pattern for a URL
        String urlRegex = "^(http|https)://[^\\s/$.?#].[^\\s]*$";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(urlRegex);

        // Test some URLs
        String url1 = "http://www.example.com";
        String url2 = "https://example.org/path/to/page";
        String url3 = "ftp://invalid-url.com"; // Invalid scheme
        String url4 = "http:// example.com"; // Invalid character (space)

        System.out.println("\nTesting URLs:");

        boolean isUrl1Valid = Pattern.matches(urlRegex, url1);
        System.out.println(url1 + " is valid: " + isUrl1Valid);

        boolean isUrl2Valid = Pattern.matches(urlRegex, url2);
        System.out.println(url2 + " is valid: " + isUrl2Valid);

        boolean isUrl3Valid = Pattern.matches(urlRegex, url3);
        System.out.println(url3 + " is valid: " + isUrl3Valid);

        boolean isUrl4Valid = Pattern.matches(urlRegex, url4);
        System.out.println(url4 + " is valid: " + isUrl4Valid);
    }
}

Aqui está o que adicionamos:

Definimos quatro variáveis String (url1, url2, url3, url4) contendo diferentes strings de exemplo, algumas URLs válidas de acordo com nosso padrão simples e algumas inválidas.
Adicionamos uma instrução de impressão para tornar a saída mais clara.
Usamos Pattern.matches(urlRegex, url) para cada string de teste. Este método retorna true se a string inteira corresponder ao padrão urlRegex e false caso contrário.
Imprimimos o resultado da validação para cada URL.

Salve o arquivo UrlValidator.java.
Compile o código modificado no Terminal:
```
javac UrlValidator.java
```
Novamente, se a compilação for bem-sucedida, não haverá saída.

Execute o programa compilado:

java UrlValidator

Você deve ver uma saída semelhante a esta:

URL Regex Pattern Defined.

Testing URLs:
http://www.example.com is valid: true
https://example.org/path/to/page is valid: true
ftp://invalid-url.com is valid: false
http:// example.com is valid: false

Esta saída mostra que nosso padrão de regex simples identificou corretamente as duas primeiras strings como URLs válidas (de acordo com o padrão) e as duas últimas como inválidas.

Você agora usou com sucesso o método Pattern.matches() para testar strings em relação a um padrão de expressão regular em Java.

Validar Esquemas de URL Comuns

Nas etapas anteriores, definimos um padrão de regex simples e usamos Pattern.matches() para testá-lo. Nosso padrão atual valida apenas URLs que começam com http ou https. No entanto, URLs podem ter outros esquemas como ftp, mailto, file, etc.

Nesta etapa, modificaremos nosso padrão de regex para incluir esquemas de URL mais comuns. Um padrão de regex mais robusto para URLs é bastante complexo, mas podemos expandir nosso padrão atual para incluir alguns esquemas mais comuns para fins de demonstração.

Vamos atualizar o arquivo UrlValidator.java.

Abra o arquivo UrlValidator.java no editor WebIDE.
Modifique a string urlRegex para incluir os esquemas ftp e mailto, além de http e https. Também adicionaremos um caso de teste para uma URL ftp.

Substitua a linha:
```
String urlRegex = "^(http|https)://[^\\s/$.?#].[^\\s]*$";
```
por:
```
String urlRegex = "^(http|https|ftp|mailto)://[^\\s/$.?#].[^\\s]*$";
```
Observe que simplesmente adicionamos |ftp|mailto dentro dos parênteses () que representam um grupo, e o símbolo | atua como um operador "OR" (OU). Isso significa que o padrão agora corresponderá a strings que começam com http, https, ftp ou mailto seguido por ://.
Adicione um novo caso de teste para uma URL FTP. Adicione as seguintes linhas após a definição de url4:
```
String url5 = "ftp://ftp.example.com/files"; // Valid FTP URL
```

Adicione a validação para url5 após a validação para url4:

boolean isUrl5Valid = Pattern.matches(urlRegex, url5);
System.out.println(url5 + " is valid: " + isUrl5Valid);

Seu método main completo agora deve ser semelhante a este:

import java.util.regex.Pattern;

public class UrlValidator {

    public static void main(String[] args) {
        // Define a simple regex pattern for a URL including more schemes
        String urlRegex = "^(http|https|ftp|mailto)://[^\\s/$.?#].[^\\s]*$";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(urlRegex);

        System.out.println("URL Regex Pattern Defined.");

        // Test some URLs
        String url1 = "http://www.example.com";
        String url2 = "https://example.org/path/to/page";
        String url3 = "invalid-url.com"; // Invalid (missing scheme)
        String url4 = "http:// example.com"; // Invalid character (space)
        String url5 = "ftp://ftp.example.com/files"; // Valid FTP URL

        System.out.println("\nTesting URLs:");

        boolean isUrl1Valid = Pattern.matches(urlRegex, url1);
        System.out.println(url1 + " is valid: " + isUrl1Valid);

        boolean isUrl2Valid = Pattern.matches(urlRegex, url2);
        System.out.println(url2 + " is valid: " + isUrl2Valid);

        boolean isUrl3Valid = Pattern.matches(urlRegex, url3);
        System.out.println(url3 + " is valid: " + isUrl3Valid);

        boolean isUrl4Valid = Pattern.matches(urlRegex, url4);
        System.out.println(url4 + " is valid: " + isUrl4Valid);

        boolean isUrl5Valid = Pattern.matches(urlRegex, url5);
        System.out.println(url5 + " is valid: " + isUrl5Valid);
    }
}

Salve o arquivo UrlValidator.java.
Compile o código atualizado no Terminal:
```
javac UrlValidator.java
```

Execute o programa compilado:

java UrlValidator

Você deve ver uma saída semelhante a esta, com a URL FTP também sendo marcada como válida:

URL Regex Pattern Defined.

Testing URLs:
http://www.example.com is valid: true
https://example.org/path/to/page is valid: true
invalid-url.com is valid: false
http:// example.com is valid: false
ftp://ftp.example.com/files is valid: true

Você modificou com sucesso o padrão de regex para incluir esquemas de URL mais comuns e testou o padrão atualizado. Isso demonstra como você pode ajustar padrões de regex para corresponder a uma gama mais ampla de entradas.

Resumo

Neste laboratório, começamos aprendendo como definir um padrão de expressão regular em Java, especificamente para validar URLs. Criamos um novo arquivo Java, UrlValidator.java, e importamos a classe java.util.regex.Pattern. Em seguida, definimos uma variável String chamada urlRegex contendo um padrão de regex básico projetado para corresponder a strings que começam com "http" ou "https" seguido por "://", e compilamos este padrão usando Pattern.compile(). Esta etapa inicial se concentrou na configuração das ferramentas necessárias e na definição do padrão principal para validação de URL usando os recursos de regex integrados do Java.