Cómo comprobar si una cadena coincide con un formato de URL en Java

Introducción

En este laboratorio, aprenderás cómo verificar si una cadena dada coincide con el formato de una URL en Java utilizando expresiones regulares. Definiremos un patrón de expresión regular (regex) específicamente diseñado para URLs, utilizaremos el método Pattern.matches() para probar cadenas contra este patrón y exploraremos cómo validar los esquemas de URL comunes. Este ejercicio práctico te guiará a través de los pasos prácticos para implementar la validación de URLs en tus aplicaciones Java.

Definir el patrón de expresión regular para URL

En este paso, aprenderemos cómo definir un patrón de expresión regular en Java para coincidir con URLs. Las expresiones regulares, a menudo abreviadas como "regex" o "regexp", son secuencias de caracteres que definen un patrón de búsqueda. Son extremadamente poderosas para la coincidencia de patrones y la manipulación de cadenas.

Para validar URLs, un patrón de expresión regular nos ayuda a verificar si una cadena dada sigue la estructura estándar de una URL (como http://www.example.com o https://example.org/path).

Vamos a crear un nuevo archivo Java para trabajar con expresiones regulares.

Abre el WebIDE. En el Explorador de archivos a la izquierda, asegúrate de estar en el directorio ~/project.
Haz clic derecho en el espacio vacío dentro del directorio ~/project y selecciona "Nuevo archivo".
Nombrar el nuevo archivo UrlValidator.java y presiona Enter.
El archivo UrlValidator.java debería abrirse en el Editor de código.
Copia y pega el siguiente código Java en el 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.");
    }
}
```
Analicemos las nuevas partes de este código:
- import java.util.regex.Pattern;: Esta línea importa la clase Pattern, que es parte del soporte integrado de Java para expresiones regulares.
- String urlRegex = "^(http|https)://[^\\s/$.?#].[^\\s]*$";: Esta línea define una variable de tipo String llamada urlRegex y le asigna nuestro patrón de expresión regular.
  - ^: Coincide con el inicio de la cadena.
  - (http|https): Coincide con "http" o "https".
  - ://: Coincide con los caracteres literales "://".
  - [^\\s/$.?#]: Coincide con cualquier carácter que no sea un espacio en blanco (\\s), una barra inclinada (/), un signo de dólar ($), un punto (.), una interrogación (?) o un signo de almohadilla (#). Esta es una forma simplificada de coincidir con la parte del nombre de dominio.
  - .: Coincide con cualquier carácter (excepto una nueva línea).
  - [^\\s]*: Coincide con cero o más caracteres que no son espacios en blanco. Esta es una forma simplificada de coincidir con el resto de la ruta y la consulta de la URL.
  - $: Coincide con el final de la cadena.
  - Ten en cuenta las dobles barras invertidas (\\) antes de s. En las cadenas de Java, una sola barra invertida es un carácter de escape, por lo que necesitamos \\ para representar una barra invertida literal en el patrón de expresión regular.
- Pattern pattern = Pattern.compile(urlRegex);: Esta línea compila la cadena de expresión regular en un objeto Pattern. Compilar el patrón es más eficiente si planeas usar el mismo patrón varias veces.
- System.out.println("URL Regex Pattern Defined.");: Esta línea simplemente imprime un mensaje en la consola para indicar que el patrón se ha definido.
Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, vamos a compilar este programa Java. Abre la Terminal en la parte inferior del WebIDE. Asegúrate de estar en el directorio ~/project.
Compila el código usando el comando javac:
```
javac UrlValidator.java
```
Si no hay errores, el comando se completará sin salida. Se creará un archivo UrlValidator.class en el directorio ~/project.
Ejecuta el programa compilado usando el comando java:
```
java UrlValidator
```
Deberías ver la salida:
```
URL Regex Pattern Defined.
```

Has definido y compilado con éxito un programa Java que incluye un patrón básico de expresión regular para URLs. En el siguiente paso, usaremos este patrón para probar si diferentes cadenas son URLs válidas.

Probar una URL con Pattern.matches()

En el paso anterior, definimos un patrón de expresión regular (regex) para URLs y lo compilamos en un objeto Pattern. Ahora, usemos este patrón para verificar si diferentes cadenas son URLs válidas utilizando el método Pattern.matches().

El método Pattern.matches(regex, input) es una forma conveniente de comprobar si una cadena de entrada completa coincide con una expresión regular dada. Compila la expresión regular y compara la entrada con ella en un solo paso.

Modifiquemos nuestro archivo UrlValidator.java para probar algunas URLs de ejemplo.

Abre el archivo UrlValidator.java en el editor del WebIDE si no está abierto.

Modifica el método main para incluir el siguiente código. Agregarás este código después de la línea 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);
    }
}

Esto es lo que hemos agregado:

Definimos cuatro variables de tipo String (url1, url2, url3, url4) que contienen diferentes cadenas de ejemplo, algunas URLs válidas según nuestro patrón simple y otras inválidas.
Agregamos una instrucción de impresión para que la salida sea más clara.
Usamos Pattern.matches(urlRegex, url) para cada cadena de prueba. Este método devuelve true si la cadena completa coincide con el patrón urlRegex, y false en caso contrario.
Imprimimos el resultado de la validación para cada URL.

Guarda el archivo UrlValidator.java.
Compila el código modificado en la Terminal:
```
javac UrlValidator.java
```
Nuevamente, si la compilación es exitosa, no habrá salida.

Ejecuta el programa compilado:

java UrlValidator

Deberías ver una salida similar 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 salida muestra que nuestro patrón simple de expresión regular identificó correctamente las dos primeras cadenas como URLs válidas (según el patrón) y las dos últimas como inválidas.

Ahora has utilizado con éxito el método Pattern.matches() para probar cadenas contra un patrón de expresión regular en Java.

Validar esquemas de URL comunes

En los pasos anteriores, definimos un patrón simple de expresión regular (regex) y usamos Pattern.matches() para probarlo. Nuestro patrón actual solo valida URLs que comienzan con http o https. Sin embargo, las URLs pueden tener otros esquemas como ftp, mailto, file, etc.

En este paso, modificaremos nuestro patrón de expresión regular para incluir más esquemas comunes de URL. Un patrón de expresión regular más robusto para URLs es bastante complejo, pero podemos expandir nuestro patrón actual para incluir algunos esquemas comunes más con fines demostrativos.

Actualicemos el archivo UrlValidator.java.

Abre el archivo UrlValidator.java en el editor del WebIDE.
Modifica la cadena urlRegex para incluir los esquemas ftp y mailto además de http y https. También agregaremos un caso de prueba para una URL ftp.

Reemplaza la línea:
```
String urlRegex = "^(http|https)://[^\\s/$.?#].[^\\s]*$";
```
con:
```
String urlRegex = "^(http|https|ftp|mailto)://[^\\s/$.?#].[^\\s]*$";
```
Observa que simplemente agregamos |ftp|mailto dentro de los paréntesis () que representan un grupo, y el símbolo | actúa como un operador "O". Esto significa que el patrón ahora coincidirá con cadenas que comiencen con http, https, ftp o mailto seguidas de ://.
Agrega un nuevo caso de prueba para una URL FTP. Agrega las siguientes líneas después de la definición de url4:
```
String url5 = "ftp://ftp.example.com/files"; // Valid FTP URL
```

Agrega la validación para url5 después de la validación para url4:

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

Tu método main completo ahora debería verse así:

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

Guarda el archivo UrlValidator.java.
Compila el código actualizado en la Terminal:
```
javac UrlValidator.java
```

Ejecuta el programa compilado:

java UrlValidator

Ahora deberías ver una salida similar a esta, con la URL FTP también 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

Has modificado con éxito el patrón de expresión regular para incluir más esquemas comunes de URL y probado el patrón actualizado. Esto demuestra cómo puedes ajustar los patrones de expresión regular para coincidir con un rango más amplio de entradas.

Resumen

En este laboratorio, comenzamos aprendiendo cómo definir un patrón de expresión regular en Java específicamente para validar URLs. Creamos un nuevo archivo Java, UrlValidator.java, e importamos la clase java.util.regex.Pattern. Luego definimos una variable de tipo String llamada urlRegex que contiene un patrón básico de expresión regular diseñado para coincidir con cadenas que comiencen con "http" o "https" seguidas de "://", y compilamos este patrón utilizando Pattern.compile(). Este primer paso se centró en configurar las herramientas necesarias y definir el patrón central para la validación de URLs utilizando las capacidades integradas de expresiones regulares de Java.