So überprüfen Sie, ob eine Zeichenkette einem URL-Format in Java entspricht

Einführung

In diesem Lab lernen Sie, wie Sie in Java mithilfe von regulären Ausdrücken prüfen können, ob eine gegebene Zeichenkette einem URL-Format entspricht. Wir werden ein speziell für URLs entwickeltes RegEx-Muster (Regulärer Ausdrucksmuster) definieren, die Methode Pattern.matches() nutzen, um Zeichenketten gegen dieses Muster zu testen, und untersuchen, wie Sie gängige URL-Schemas validieren können. Diese praktische Übung führt Sie durch die Schritte zur Implementierung der URL-Validierung in Ihren Java-Anwendungen.

Definieren des URL-RegEx-Musters

In diesem Schritt lernen wir, wie man in Java ein reguläres Ausdrucksmuster (RegEx-Muster) definiert, um URLs zu matchen. Reguläre Ausdrücke, oft abgekürzt als "regex" oder "regexp", sind Zeichenfolgen, die ein Suchmuster definieren. Sie sind äußerst leistungsstark für die Mustererkennung und Manipulation von Zeichenketten.

Für die Validierung von URLs hilft uns ein RegEx-Muster zu prüfen, ob eine gegebene Zeichenkette der Standardstruktur einer URL folgt (z.B. http://www.example.com oder https://example.org/path).

Lassen Sie uns eine neue Java-Datei erstellen, um mit RegEx zu arbeiten.

Öffnen Sie die WebIDE. Stellen Sie im Dateiexplorer links sicher, dass Sie sich im Verzeichnis ~/project befinden.
Klicken Sie mit der rechten Maustaste in den leeren Bereich des ~/project-Verzeichnisses und wählen Sie "Neue Datei".
Benennen Sie die neue Datei UrlValidator.java und drücken Sie die Eingabetaste.
Die Datei UrlValidator.java sollte im Code-Editor geöffnet werden.
Kopieren und fügen Sie den folgenden Java-Code in den Editor ein:
```
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.");
    }
}
```
Lassen Sie uns die neuen Teile dieses Codes analysieren:
- import java.util.regex.Pattern;: Diese Zeile importiert die Pattern-Klasse, die Teil der integrierten Unterstützung für reguläre Ausdrücke in Java ist.
- String urlRegex = "^(http|https)://[^\\s/$.?#].[^\\s]*$";: Diese Zeile definiert eine String-Variable namens urlRegex und weist ihr unser reguläres Ausdrucksmuster zu.
  - ^: Passt an den Anfang der Zeichenkette.
  - (http|https): Passt entweder auf "http" oder "https".
  - ://: Passt auf die literalen Zeichen "://".
  - [^\\s/$.?#]: Passt auf jedes Zeichen, das KEIN Leerzeichen (\\s), kein Schrägstrich (/), kein Dollarzeichen ($), kein Punkt (.), kein Fragezeichen (?) oder kein Hashtag (#) ist. Dies ist eine vereinfachte Methode, um den Domainnamen-Teil zu matchen.
  - .: Passt auf jedes Zeichen (außer Zeilenumbruch).
  - [^\\s]*: Passt auf null oder mehr Zeichen, die KEINE Leerzeichen sind. Dies ist eine vereinfachte Methode, um den Rest des URL-Pfads und der Abfrage zu matchen.
  - $: Passt an das Ende der Zeichenkette.
  - Beachten Sie die doppelten Backslashes (\\) vor s. In Java-Zeichenketten ist ein einzelner Backslash ein Escape-Zeichen, daher benötigen wir \\, um einen literalen Backslash im RegEx-Muster darzustellen.
- Pattern pattern = Pattern.compile(urlRegex);: Diese Zeile kompiliert die RegEx-Zeichenkette in ein Pattern-Objekt. Das Kompilieren des Musters ist effizienter, wenn Sie dasselbe Muster mehrmals verwenden möchten.
- System.out.println("URL Regex Pattern Defined.");: Diese Zeile gibt einfach eine Nachricht in die Konsole aus, um anzuzeigen, dass das Muster definiert wurde.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt lassen Sie uns dieses Java-Programm kompilieren. Öffnen Sie das Terminal unten in der WebIDE. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
Kompilieren Sie den Code mit dem javac-Befehl:
```
javac UrlValidator.java
```
Wenn keine Fehler auftreten, wird der Befehl ohne Ausgabe abgeschlossen. Eine UrlValidator.class-Datei wird im ~/project-Verzeichnis erstellt.
Führen Sie das kompilierte Programm mit dem java-Befehl aus:
```
java UrlValidator
```
Sie sollten die folgende Ausgabe sehen:
```
URL Regex Pattern Defined.
```

Sie haben erfolgreich ein Java-Programm definiert und kompiliert, das ein einfaches RegEx-Muster für URLs enthält. Im nächsten Schritt werden wir dieses Muster verwenden, um zu testen, ob verschiedene Zeichenketten gültige URLs sind.

Testen von URLs mit Pattern.matches()

Im vorherigen Schritt haben wir ein RegEx-Muster für URLs definiert und es in ein Pattern-Objekt kompiliert. Jetzt verwenden wir dieses Muster, um zu prüfen, ob verschiedene Zeichenketten gültige URLs sind, indem wir die Methode Pattern.matches() nutzen.

Die Methode Pattern.matches(regex, input) ist eine bequeme Möglichkeit, zu prüfen, ob eine gesamte Eingabezeichenkette einem gegebenen regulären Ausdruck entspricht. Sie kompiliert den RegEx und vergleicht die Eingabe damit in einem einzigen Schritt.

Lassen Sie uns die Datei UrlValidator.java ändern, um einige Beispiel-URLs zu testen.

Öffnen Sie die Datei UrlValidator.java im WebIDE-Editor, falls sie noch nicht geöffnet ist.

Ändern Sie die main-Methode, um den folgenden Code einzufügen. Sie fügen diesen Code nach der Zeile Pattern pattern = Pattern.compile(urlRegex); hinzu.

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

Hier ist, was wir hinzugefügt haben:

Wir haben vier String-Variablen (url1, url2, url3, url4) definiert, die verschiedene Beispielzeichenketten enthalten, einige gültige URLs gemäß unserem einfachen Muster und einige ungültige.
Wir haben eine Ausgabebefehl hinzugefügt, um die Ausgabe klarer zu gestalten.
Wir haben Pattern.matches(urlRegex, url) für jede Testzeichenkette verwendet. Diese Methode gibt true zurück, wenn die gesamte Zeichenkette dem urlRegex-Muster entspricht, und false sonst.
Wir haben das Ergebnis der Validierung für jede URL ausgegeben.

Speichern Sie die Datei UrlValidator.java.
Kompilieren Sie den geänderten Code im Terminal:
```
javac UrlValidator.java
```
Wiederum wird bei erfolgreichem Kompilieren keine Ausgabe angezeigt.

Führen Sie das kompilierte Programm aus:

java UrlValidator

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Diese Ausgabe zeigt, dass unser einfaches RegEx-Muster die ersten beiden Zeichenketten korrekt als gültige URLs (gemäß dem Muster) und die letzten beiden als ungültig identifiziert hat.

Sie haben nun erfolgreich die Methode Pattern.matches() verwendet, um Zeichenketten gegen ein reguläres Ausdrucksmuster in Java zu testen.

Validieren gängiger URL-Schemas

In den vorherigen Schritten haben wir ein einfaches RegEx-Muster definiert und Pattern.matches() verwendet, um es zu testen. Unser aktuelles Muster validiert nur URLs, die mit http oder https beginnen. URLs können jedoch auch andere Schemas wie ftp, mailto, file usw. haben.

In diesem Schritt werden wir unser RegEx-Muster ändern, um mehr gängige URL-Schemas einzubeziehen. Ein robusteres RegEx-Muster für URLs ist recht komplex, aber wir können unser aktuelles Muster erweitern, um einige weitere gängige Schemas zu demonstrieren.

Lassen Sie uns die Datei UrlValidator.java aktualisieren.

Öffnen Sie die Datei UrlValidator.java im WebIDE-Editor.
Ändern Sie die urlRegex-Zeichenkette, um die Schemas ftp und mailto zusätzlich zu http und https einzubeziehen. Wir werden auch einen Testfall für eine ftp-URL hinzufügen.

Ersetzen Sie die Zeile:
```
String urlRegex = "^(http|https)://[^\\s/$.?#].[^\\s]*$";
```
durch:
```
String urlRegex = "^(http|https|ftp|mailto)://[^\\s/$.?#].[^\\s]*$";
```
Beachten Sie, dass wir einfach |ftp|mailto innerhalb der Klammern () hinzugefügt haben, die eine Gruppe darstellen, und das |-Symbol fungiert als "ODER"-Operator. Dies bedeutet, dass das Muster jetzt Zeichenketten matchen wird, die mit http, https, ftp oder mailto gefolgt von :// beginnen.
Fügen Sie einen neuen Testfall für eine FTP-URL hinzu. Fügen Sie die folgenden Zeilen nach der Definition von url4 hinzu:
```
String url5 = "ftp://ftp.example.com/files"; // Valid FTP URL
```

Fügen Sie die Validierung für url5 nach der Validierung für url4 hinzu:

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

Ihre vollständige main-Methode sollte jetzt wie folgt aussehen:

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

Speichern Sie die Datei UrlValidator.java.
Kompilieren Sie den aktualisierten Code im Terminal:
```
javac UrlValidator.java
```

Führen Sie das kompilierte Programm aus:

java UrlValidator

Sie sollten jetzt eine Ausgabe ähnlich der folgenden sehen, wobei auch die FTP-URL als gültig markiert wird:

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

Sie haben erfolgreich das RegEx-Muster geändert, um mehr gängige URL-Schemas einzubeziehen, und das aktualisierte Muster getestet. Dies zeigt, wie Sie RegEx-Muster anpassen können, um eine breitere Palette von Eingaben zu matchen.

Zusammenfassung

In diesem Lab haben wir zunächst gelernt, wie man in Java ein reguläres Ausdrucksmuster (Regular Expression Pattern) speziell für die Validierung von URLs definiert. Wir haben eine neue Java-Datei namens UrlValidator.java erstellt und die Klasse java.util.regex.Pattern importiert. Anschließend haben wir eine String-Variable urlRegex definiert, die ein einfaches RegEx-Muster enthält, das auf Zeichenketten passt, die mit "http" oder "https" gefolgt von "://" beginnen. Wir haben dieses Muster mit Pattern.compile() kompiliert. Dieser erste Schritt konzentrierte sich darauf, die erforderlichen Werkzeuge einzurichten und das Kernmuster für die URL-Validierung unter Verwendung der integrierten RegEx-Fähigkeiten von Java zu definieren.