Comment vérifier si une chaîne de caractères correspond à un format d'URL en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une chaîne de caractères donnée correspond au format d'une URL en Java en utilisant des expressions régulières. Nous allons définir un modèle d'expression régulière (regex) spécialement conçu pour les URLs, utiliser la méthode Pattern.matches() pour tester les chaînes de caractères par rapport à ce modèle, et explorer comment valider les schémas d'URL courants. Cet exercice pratique vous guidera à travers les étapes pratiques de mise en œuvre de la validation d'URL dans vos applications Java.

Skills Graph

Définir un modèle d'expression régulière (regex) pour les URLs

Dans cette étape, nous apprendrons à définir un modèle d'expression régulière en Java pour correspondre aux URLs. Les expressions régulières, souvent abrégées en "regex" ou "regexp", sont des séquences de caractères qui définissent un modèle de recherche. Elles sont extrêmement puissantes pour la correspondance de motifs et la manipulation de chaînes de caractères.

Pour valider les URLs, un modèle d'expression régulière nous aide à vérifier si une chaîne de caractères donnée suit la structure standard d'une URL (comme http://www.example.com ou https://example.org/path).

Créons un nouveau fichier Java pour travailler avec les expressions régulières.

1. Ouvrez l'WebIDE. Dans l'explorateur de fichiers à gauche, assurez-vous d'être dans le répertoire ~/project.

2. Cliquez avec le bouton droit dans l'espace vide du répertoire ~/project et sélectionnez "Nouveau fichier".

3. Nommez le nouveau fichier UrlValidator.java et appuyez sur Entrée.

4. Le fichier UrlValidator.java devrait s'ouvrir dans l'éditeur de code.

5. Copiez et collez le code Java suivant dans l'éditeur :

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

   Analysons les nouvelles parties de ce code :

   • import java.util.regex.Pattern; : Cette ligne importe la classe Pattern, qui fait partie du support intégré des expressions régulières de Java.
   • String urlRegex = "^(http|https)://[^\\s/$.?#].[^\\s]*$"; : Cette ligne définit une variable de type String nommée urlRegex et lui assigne notre modèle d'expression régulière.
     • ^ : Correspond au début de la chaîne de caractères.
     • (http|https) : Correspond soit à "http" soit à "https".
     • :// : Correspond aux caractères littéraux "://".
     • [^\\s/$.?#] : Correspond à tout caractère qui n'est PAS un caractère d'espacement (\\s), une barre oblique (/), un signe dollar ($), un point (.), un point d'interrogation (?) ou un symbole dièse (#). C'est une façon simplifiée de correspondre à la partie du nom de domaine.
     • . : Correspond à n'importe quel caractère (sauf le saut de ligne).
     • [^\\s]* : Correspond à zéro ou plusieurs caractères qui ne sont pas des espaces. C'est une façon simplifiée de correspondre au reste du chemin d'URL et de la requête.
     • $ : Correspond à la fin de la chaîne de caractères.
     • Notez les doubles barres obliques inverses (\\) avant s. Dans les chaînes de caractères Java, une seule barre oblique inverse est un caractère d'échappement, donc nous avons besoin de \\ pour représenter une barre oblique inverse littérale dans le modèle d'expression régulière.
   • Pattern pattern = Pattern.compile(urlRegex); : Cette ligne compile la chaîne d'expression régulière en un objet Pattern. Compiler le modèle est plus efficace si vous prévoyez d'utiliser le même modèle plusieurs fois.
   • System.out.println("URL Regex Pattern Defined."); : Cette ligne affiche simplement un message dans la console pour indiquer que le modèle a été défini.

6. Enregistrez le fichier (Ctrl+S ou Cmd+S).

7. Maintenant, compilons ce programme Java. Ouvrez le terminal en bas de l'WebIDE. Assurez-vous d'être dans le répertoire ~/project.

8. Compilez le code en utilisant la commande javac :

   javac UrlValidator.java

   S'il n'y a pas d'erreurs, la commande se terminera sans afficher de sortie. Un fichier UrlValidator.class sera créé dans le répertoire ~/project.

9. Exécutez le programme compilé en utilisant la commande java :

   java UrlValidator

   Vous devriez voir la sortie suivante :

   URL Regex Pattern Defined.

Vous avez réussi à définir et compiler un programme Java qui inclut un modèle d'expression régulière de base pour les URLs. Dans l'étape suivante, nous utiliserons ce modèle pour tester si différentes chaînes de caractères sont des URLs valides.

Tester une URL avec Pattern.matches()

Dans l'étape précédente, nous avons défini un modèle d'expression régulière (regex) pour les URLs et l'avons compilé en un objet Pattern. Maintenant, utilisons ce modèle pour vérifier si différentes chaînes de caractères sont des URLs valides en utilisant la méthode Pattern.matches().

La méthode Pattern.matches(regex, input) est un moyen pratique de vérifier si une chaîne de caractères d'entrée entière correspond à une expression régulière donnée. Elle compile l'expression régulière et vérifie si l'entrée correspond à celle-ci en une seule étape.

Modifions notre fichier UrlValidator.java pour tester quelques exemples d'URLs.

1. Ouvrez le fichier UrlValidator.java dans l'éditeur de l'WebIDE s'il n'est pas déjà ouvert.

2. Modifiez la méthode main pour inclure le code suivant. Vous ajouterez ce code après la ligne 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);
       }
   }

   Voici ce que nous avons ajouté :

   • Nous avons défini quatre variables de type String (url1, url2, url3, url4) contenant différentes chaînes de caractères d'exemple, certaines étant des URLs valides selon notre modèle simple, et d'autres étant invalides.
   • Nous avons ajouté une instruction d'impression pour rendre la sortie plus claire.
   • Nous avons utilisé Pattern.matches(urlRegex, url) pour chaque chaîne de caractères de test. Cette méthode renvoie true si la chaîne de caractères entière correspond au modèle urlRegex, et false sinon.
   • Nous avons imprimé le résultat de la validation pour chaque URL.

3. Enregistrez le fichier UrlValidator.java.

4. Compilez le code modifié dans le terminal :

   javac UrlValidator.java

   Encore une fois, si la compilation réussit, il n'y aura pas de sortie.

5. Exécutez le programme compilé :

   java UrlValidator

   Vous devriez voir une sortie similaire à celle-ci :

   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

Cette sortie montre que notre modèle d'expression régulière simple a correctement identifié les deux premières chaînes de caractères comme des URLs valides (selon le modèle) et les deux dernières comme invalides.

Vous avez maintenant réussi à utiliser la méthode Pattern.matches() pour tester des chaînes de caractères par rapport à un modèle d'expression régulière en Java.

Valider les schémas d'URL courants

Dans les étapes précédentes, nous avons défini un modèle d'expression régulière (regex) simple et utilisé Pattern.matches() pour le tester. Notre modèle actuel ne valide que les URLs commençant par http ou https. Cependant, les URLs peuvent avoir d'autres schémas comme ftp, mailto, file, etc.

Dans cette étape, nous allons modifier notre modèle d'expression régulière pour inclure plus de schémas d'URL courants. Un modèle d'expression régulière plus robuste pour les URLs est assez complexe, mais nous pouvons étendre notre modèle actuel pour inclure quelques schémas courants supplémentaires à des fins de démonstration.

Mettons à jour le fichier UrlValidator.java.

1. Ouvrez le fichier UrlValidator.java dans l'éditeur de l'WebIDE.

2. Modifiez la chaîne urlRegex pour inclure les schémas ftp et mailto en plus de http et https. Nous allons également ajouter un cas de test pour une URL ftp.

   Remplacez la ligne :

   String urlRegex = "^(http|https)://[^\\s/$.?#].[^\\s]*$";

   par :

   String urlRegex = "^(http|https|ftp|mailto)://[^\\s/$.?#].[^\\s]*$";

   Notez que nous avons simplement ajouté |ftp|mailto à l'intérieur des parenthèses () qui représentent un groupe, et le symbole | agit comme un opérateur "OU". Cela signifie que le modèle correspondra maintenant aux chaînes commençant par http, https, ftp ou mailto suivies de ://.

3. Ajoutez un nouveau cas de test pour une URL FTP. Ajoutez les lignes suivantes après la définition de url4 :

   String url5 = "ftp://ftp.example.com/files"; // Valid FTP URL

4. Ajoutez la validation pour url5 après la validation pour url4 :

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

   Votre méthode main complète devrait maintenant ressembler à ceci :

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

5. Enregistrez le fichier UrlValidator.java.

6. Compilez le code mis à jour dans le terminal :

   javac UrlValidator.java

7. Exécutez le programme compilé :

   java UrlValidator

   Vous devriez maintenant voir une sortie similaire à celle-ci, avec l'URL FTP également marquée comme valide :

   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

Vous avez réussi à modifier le modèle d'expression régulière pour inclure plus de schémas d'URL courants et à tester le modèle mis à jour. Cela démontre comment vous pouvez ajuster les modèles d'expression régulière pour correspondre à une gamme plus large d'entrées.

Résumé

Dans ce laboratoire (lab), nous avons commencé par apprendre à définir un modèle d'expression régulière (regex) en Java pour valider spécifiquement les URLs. Nous avons créé un nouveau fichier Java, UrlValidator.java, et importé la classe java.util.regex.Pattern. Nous avons ensuite défini une variable de type String nommée urlRegex contenant un modèle d'expression régulière de base conçu pour correspondre aux chaînes commençant par "http" ou "https" suivies de "://", et avons compilé ce modèle à l'aide de Pattern.compile(). Cette première étape s'est concentrée sur la mise en place des outils nécessaires et la définition du modèle de base pour la validation des URLs en utilisant les capacités intégrées de regex de Java.