TOC

Un guide sur l’URL Java

Un guide sur l'URL Java

1. Vue d'ensemble

Dans cet article, nous allons explorer les opérations de bas niveau avec la programmation réseau Java. We’ll be taking a deeper look at URLs.

Une URL est une référence ou une adresse à une ressource du réseau. En termes simples, le code Java communiquant sur le réseau peut utiliser la classejava.net.URL pour représenter les adresses des ressources.

La plate-forme Java est livrée avec une prise en charge réseau intégrée, intégrée dans le packagejava.net: 

import java.net.*;

2. Créer une URL

Créons d'abord un objetjava.net.URL en utilisant son constructeur et en passant une chaîne représentant l'adresse lisible par l'homme de la ressource: 

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

Nous venons de créer unabsolute URL object. L'adresse contient toutes les pièces nécessaires pour atteindre la ressource souhaitée.

Nous pouvons également créera relative URL; en supposant que nous avons l'objet URL représentant la page d'accueil de l'exemple: 

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

Ensuite, créons une nouvelle URL pointant vers une ressource que nous connaissons déjà; nous allons utiliser un autre constructeur, qui prend à la fois une URL existante et un nom de ressource par rapport à cette URL: 

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

Nous avons maintenant créé un nouvel objet URLurl par rapport àhome; donc l'URL relative n'est valide que dans le contexte de l'URL de base.

Nous pouvons le voir dans un test: 

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

Cependant, si l'URL relative est détectée comme absolue dans ses composants, alors lebaseURL est ignoré: 

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

Enfin, nous pouvons créer une URL en appelant un autre constructeur qui intègre les composants de la chaîne d'URL. Nous couvrirons cela dans la section suivante après avoir traité les composants d'URL.

3. Composants URL

Une URL est composée de quelques composants - que nous explorerons dans cette section.

Examinons d'abord la séparation entre l'identifiant de protocole et la ressource - ces deux composants sont séparés par un deux-points suivi de deux barres obliques, c'est-à-dire ://.

Si nous avons une URL telle quehttp://example.com alors la partie avant le séparateur,http, est l'identifiant du protocole tandis que celle qui suit est le nom de la ressource,example.com.

Jetons un coup d'œil à l'API que l'objetURL expose.

3.1. Le protocole

Pour récupérerthe protocol - nous utilisons la méthodegetProtocol(): 

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

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

3.2. Le port

Pour obtenirthe port - nous utilisons la méthodegetPort(): 

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

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

Notez que cette méthode récupère le port explicitement défini. Si aucun port n'est défini explicitement, il retournera -1.

Et comme la communication HTTP utilise le port 80 par défaut, aucun port n’est défini.

Voici un exemple où nous avons un port explicitement défini: 

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

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

3.3. L'hôte

The host est la partie du nom de la ressource qui commence juste après le séparateur:// et se termine par l'extension du nom de domaine, dans notre cas.com.

Nous appelons la méthodegetHost() pour récupérer le nom d'hôte: 

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

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

3.4. Le nom du fichier

Tout ce qui suit le nom d'hôte dans une URL est appeléfile name of the resource. Il peut inclure à la fois des paramètres de chemin et de requête ou juste un nom de fichier: 

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

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

En supposant que l'exemple a java 8 articles sous l'URL/articles?topic=java&version=8. Tout ce qui suit le nom d’hôte est le nom du fichier: 

@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. Paramètres de chemin

Nous ne pouvons également inspecter que les paramètresthe path qui dans notre cas sont/articles: 

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

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

3.6. Paramètres de requête

De même, nous pouvons inspecterthe query parameters qui esttopic=java&version=8: 

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

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

4. Création d'URL avec des composants

Puisque nous avons maintenant examiné les différents composants d'URL et leur place dans la formation de l'adresse complète de la ressource, nous pouvons examiner une autre méthode de création d'un objet URL en transmettant les composants.

Le premier constructeur prend respectivement le protocole, le nom d'hôte et le nom de fichier: 

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

Gardez à l'esprit la signification du nom de fichier dans ce contexte, le test suivant devrait le rendre plus clair: 

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

Le second constructeur prend respectivement le protocole, le nom d’hôte, le numéro de port et le nom de fichier: 

@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. Conclusion

Dans ce didacticiel, nous avons couvert la classeURL et montré comment l'utiliser en Java pour accéder aux ressources réseau par programmation.

Comme toujours, le code source complet de l'article et tous les extraits de code se trouvent dans lesGitHub project.

Related