TOC

Ein Leitfaden zur Java-URL

Ein Leitfaden zur Java-URL

1. Überblick

In diesem Artikel werden Operationen auf niedriger Ebene mit der Java-Netzwerkprogrammierung untersucht. We’ll be taking a deeper look at URLs.

Eine URL ist eine Referenz oder eine Adresse zu einer Ressource im Netzwerk. Einfach ausgedrückt kann Java-Code, der über das Netzwerk kommuniziert, die Klassejava.net.URLverwenden, um die Adressen von Ressourcen darzustellen.

Die Java-Plattform wird mit integrierter Netzwerkunterstützung geliefert, die im Paketjava.netenthalten ist: 

import java.net.*;

2. URL erstellen

Erstellen wir zunächst einjava.net.URL-Objekt, indem wir seinen Konstruktor verwenden und einen String übergeben, der die vom Menschen lesbare Adresse der Ressource darstellt: 

URL url = new URL("/a-guide-to-java-sockets");

Wir haben gerade einabsolute URL object erstellt. Die Adresse enthält alle Teile, die erforderlich sind, um die gewünschte Ressource zu erreichen.

Wir können aucha relative URL erstellen; Angenommen, wir haben das URL-Objekt, das die Homepage des Beispiels darstellt: 

URL home = new URL("http://example.com");

Als Nächstes erstellen wir eine neue URL, die auf eine bereits bekannte Ressource verweist. Wir werden einen anderen Konstruktor verwenden, der sowohl eine vorhandene URL als auch einen Ressourcennamen relativ zu dieser URL verwendet: 

URL url = new URL(home, "a-guide-to-java-sockets");

Wir haben jetzt ein neues URL-Objekturl relativ zuhome erstellt. Daher ist die relative URL nur im Kontext der Basis-URL gültig.

Wir können dies in einem Test sehen: 

@Test
public void givenBaseUrl_whenCreatesRelativeUrl_thenCorrect() {
    URL baseUrl = new URL("http://example.com");
    URL relativeUrl = new URL(baseUrl, "a-guide-to-java-sockets");

    assertEquals(
      "/a-guide-to-java-sockets",
      relativeUrl.toString());
}

Wenn jedoch festgestellt wird, dass die relative URL in ihren Bestandteilen absolut ist, wirdbaseURL ignoriert: 

@Test
public void givenAbsoluteUrl_whenIgnoresBaseUrl_thenCorrect() {
    URL baseUrl = new URL("http://example.com");
    URL relativeUrl = new URL(
      baseUrl, "/a-guide-to-java-sockets");

    assertEquals(
      "/a-guide-to-java-sockets",
      relativeUrl.toString());
}

Zum Schluss können wir eine URL erstellen, indem wir einen anderen Konstruktor aufrufen, der die Bestandteile der URL-Zeichenfolge aufnimmt. Wir werden dies im nächsten Abschnitt behandeln, nachdem wir die URL-Komponenten behandelt haben.

3. URL-Komponenten

Eine URL besteht aus einigen Komponenten, die wir in diesem Abschnitt untersuchen werden.

Betrachten wir zunächst die Trennung zwischen der Protokollkennung und der Ressource. Diese beiden Komponenten werden durch einen Doppelpunkt gefolgt von zwei Schrägstrichen getrennt, d. H. ://.

Wenn wir eine URL wiehttp://example.com haben, ist der Teil vor dem Trennzeichenhttp, die Protokollkennung, während die folgende der Ressourcennameexample.com ist.

Schauen wir uns die API an, die das ObjektURLverfügbar macht.

3.1. Das Protokoll

Umthe protocol abzurufen, verwenden wir die MethodegetProtocol(): 

@Test
public void givenUrl_whenCanIdentifyProtocol_thenCorrect(){
    URL url = new URL("http://example.com");

    assertEquals("http", url.getProtocol());
}

3.2. Der Hafen

Umthe port zu erhalten, verwenden wir die MethodegetPort(): 

@Test
public void givenUrl_whenGetsDefaultPort_thenCorrect(){
    URL url = new URL("http://example.com");

    assertEquals(-1, url.getPort());
    assertEquals(80, url.getDefaultPort());
}

Beachten Sie, dass diese Methode den explizit definierten Port abruft. Wenn kein Port explizit definiert ist, wird -1 zurückgegeben.

Und da die HTTP-Kommunikation standardmäßig Port 80 verwendet, ist kein Port definiert.

Hier ist ein Beispiel, in dem wir einen explizit definierten Port haben: 

@Test
public void givenUrl_whenGetsPort_thenCorrect(){
    URL url = new URL("http://example.com:8090");

    assertEquals(8090, url.getPort());
}

3.3. Der Gastgeber

The host ist der Teil des Ressourcennamens, der direkt nach dem Trennzeichen:// beginnt und mit der Domainnamenerweiterung endet, in unserem Fall.com.

Wir rufen die MethodegetHost()auf, um den Hostnamen abzurufen: 

@Test
public void givenUrl_whenCanGetHost_thenCorrect(){
    URL url = new URL("http://example.com");

    assertEquals("example.com", url.getHost());
}

3.4. Der Dateiname

Was auch immer nach dem Hostnamen in einer URL folgt, wird alsfile name of the resource bezeichnet. Es kann sowohl Pfad- als auch Abfrageparameter oder nur einen Dateinamen enthalten: 

@Test
public void givenUrl_whenCanGetFileName_thenCorrect1() {
    URL url = new URL("/guidelines.txt");

    assertEquals("/guidelines.txt", url.getFile());
}

Angenommen, das Beispiel enthält Java 8-Artikel unter der URL/articles?topic=java&version=8. Alles nach dem Hostnamen ist der Dateiname: 

@Test
public void givenUrl_whenCanGetFileName_thenCorrect2() {
    URL url = new URL(
      "/articles?topic=java&version=8");

    assertEquals("/articles?topic=java&version=8", url.getFile());
}

3.5. Pfadparameter

Wir können auch nurthe path Parameter untersuchen, die in unserem Fall/articles sind: 

@Test
public void givenUrl_whenCanGetPathParams_thenCorrect() {
    URL url = new URL(
      "/articles?topic=java&version=8");

    assertEquals("/articles", url.getPath());
}

3.6. Abfrageparameter

Ebenso können wirthe query parameters untersuchen, wastopic=java&version=8 ist: 

@Test
public void givenUrl_whenCanGetQueryParams_thenCorrect() {
    URL url = new URL("/articles?topic=java&version=8");

    assertEquals("topic=java&version=8", url.getQuery());
}

4. URL mit Komponenten erstellen

Da wir uns nun die verschiedenen URL-Komponenten und ihren Platz beim Bilden der vollständigen Adresse für die Ressource angesehen haben, können wir uns eine andere Methode zum Erstellen eines URL-Objekts ansehen, indem wir die Komponenten übergeben.

Der erste Konstruktor verwendet das Protokoll, den Hostnamen und den Dateinamen: 

@Test
public void givenUrlComponents_whenConstructsCompleteUrl_thenCorrect() {
    String protocol = "http";
    String host = "example.com";
    String file = "/guidelines.txt";
    URL url = new URL(protocol, host, file);

    assertEquals("/guidelines.txt", url.toString());
}

Beachten Sie in diesem Zusammenhang die Bedeutung des Dateinamens. Der folgende Test sollte dies verdeutlichen: 

@Test
public void givenUrlComponents_whenConstructsCompleteUrl_thenCorrect2() {
    String protocol = "http";
    String host = "example.com";
    String file = "/articles?topic=java&version=8";
    URL url = new URL(protocol, host, file);

    assertEquals("/guidelines.txt", url.toString());
}

Der zweite Konstruktor übernimmt das Protokoll, den Hostnamen, die Portnummer und den Dateinamen: 

@Test
public void givenUrlComponentsWithPort_whenConstructsCompleteUrl_
  thenCorrect() {
    String protocol = "http";
    String host = "example.com";
    int port = 9000;
    String file = "/guidelines.txt";
    URL url = new URL(protocol, host, port, file);

    assertEquals(
      "http://example.com:9000/guidelines.txt", url.toString());
}

5. Fazit

In diesem Tutorial haben wir dieURL-Klasse behandelt und gezeigt, wie man sie in Java verwendet, um programmgesteuert auf Netzwerkressourcen zuzugreifen.

Wie immer finden Sie den vollständigen Quellcode für den Artikel und alle Codefragmente inGitHub project.

Related