• 6 hours
  • Hard

Free online content available in this course.

course.header.alt.is_certifying

Got it!

Last updated on 2/6/20

Créez votre premier programme réseau

Log in or subscribe for free to enjoy all this course has to offer!

Avant de voir comment faire communiquer des applications sur le réseau avec votre langage favori, je vous propose de créer votre premier programme réseau pour vous familiariser avec la manipulation d'adresses IP... car comme vous l'aurez compris, c'est l'élément fondamental de toute communication utilisant le modèle TCP/IP.

Ce chapitre ne sera pas très difficile ni très long car Java nous simplifie grandement la vie avec ses objets, donc rentrons tout de suite dans le vif du sujet.

La classe InetAddress 

Comme son nom l'indique, la classe InetAddress permet de manipuler des adresses Internet, communément appelées adresses IP.
Par contre, vous ne pouvez pas instancier cette classe directement, vous devez passer par une méthode statique de cet objet afin d'en récupérer une instance…

Voyez plutôt comment cette méthode fonctionne :

import java.net.InetAddress;
import java.net.UnknownHostException;
public class Inet {
public static void main(String[] args) {
try {
InetAddress address = InetAddress.getLocalHost();
showInformations(address, "Hôte local");
address = InetAddress.getByAddress(
new byte[]{(byte)192, (byte)168, 2, 44}
);
showInformations(address, "192.168.2.44");
address = InetAddress.getByName("localhost");
showInformations(address, "locahost");
address = InetAddress.getByName("127.0.0.1");
showInformations(address, "127.0.0.1");
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
public static void showInformations(InetAddress address, String name){
System.out.println("-----------------------------------------------");
System.out.println("INFORMATIONS DE " + name);
System.out.println("-----------------------------------------------");
System.out.println("Nom : " + address.getHostName());
System.out.println("Adresse : " + address.getHostAddress());
System.out.println("Nom canonique : " + address.getCanonicalHostName());
//Cette méthode nous retourne un tableau de byte
byte[] bAddress = address.getAddress();
String ip = "";
for(byte b : bAddress)
ip +=(b & 0xFF) + ".";//L'instruction & 0xFF permet d'avoir la valeur non signée
System.out.println("Adresse IP depuis tableau de byte : " + ip);
}
}

Ce qui vous donne :

Informations récupérées avec l'objet InetAddress
Informations récupérées avec l'objet InetAddress

Ici, vous pouvez voir qu'il y a des informations sur deux adresses IP différentes : 192.168.2.44 et 127.0.0.1.
Ces deux adresses IP appartiennent à mon poste, la première représente son adresse dans le réseau dans lequel je me trouve et la seconde est ce qu'on appelle son adresse de "boucle locale" : elle sert essentiellement pour que votre machine puisse se parler à elle-même. ;)
Vous constaterez aussi que si l'hôte sur lequel nous souhaitons faire une recherche est inconnu, l'objet InetAddress lèvera une exception de type UnknownHostException.

Attends deux minutes ! Qu'est-ce que c'est que cette ligne : ip +=(b & 0xFF) + "."; ?

Je me doutais que celle-ci allait vous chatouiller un peu…
En fait, c'est relativement simple, les données retournées par la méthode getAddress(), donc dans le tableau de byte, sont des données "signées". Rappelez-vous du chapitre sur les variables de mon cours sur Java : je vous avais alors dit que les variables de type byte peuvent contenir des valeurs comprise entre -128 et +127. Or nous avons vu dans le chapitre précédent qu'une adresse IP peut contenir des valeurs entre 0 et 255. Il faudrait donc faire en sorte que nos valeurs, contenues dans le tableau de byte soient considérées comme non signées... et bien justement, c'est ce que fait cette instruction ip += (b & xFF) + "."; !

Vous devez aussi savoir qu'une machine peut avoir une multitude d'adresses IP, surtout si elle possède plusieurs cartes réseaux. Pour pouvoir facilement lister toutes ces adresses, Java met à disposition une classe NetworkInterface permettant de lister toutes les interfaces réseaux et de récupérer toutes les adresses IP de toutes les interfaces.
Voici comment elle s'utilise :

import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
public class Network {
public static void main(String[] args) {
try {
Enumeration<NetworkInterface> list = NetworkInterface.getNetworkInterfaces();
while(list.hasMoreElements()){
NetworkInterface ni = list.nextElement();
Enumeration<InetAddress> listAddress = ni.getInetAddresses();
while(listAddress.hasMoreElements()){
InetAddress address = listAddress.nextElement();
showInformations(address);
}
}
} catch (SocketException e) {
e.printStackTrace();
}
}
public static void showInformations(InetAddress address){
System.out.println("-----------------------------------------------");
System.out.println("Nom : " + address.getHostName());
System.out.println("Adresse : " + address.getHostAddress());
System.out.println("Nom canonique : " + address.getCanonicalHostName());
}
}

Ce qui vous donne ceci :

Utilisation de NetworkInterface
Utilisation de NetworkInterface

Très simple n'est-ce pas ? Ici, vous pouvez donc voir les même adresses que dans le précédent code mais aussi de nouvelles adresses, sous le format IP V6 et d'autres encore sous le format IP V4. Vous voyez donc toutes les adresses utilisables par ma machine et utilisable par les autres pour me contacter.

Nous avons donc vu comment récupérer différentes informations sur les adresses IP de nos machines, mais vous pouvez tout aussi bien faire la même chose pour des sites Internet, comme le site OpenClassrooms, regardez plutôt :

import java.net.InetAddress;
import java.net.UnknownHostException;
public class Inet2 {
public static void main(String[] args) {
try {
//Nous appelons une méthode statique de cet objet pour en récupérer une instance
InetAddress address = InetAddress.getByName("openclassrooms.com");
System.out.println("L'adresse IP de " + address.getHostName() + " est : " + address.getHostAddress());
//Certains sites Internet peuvent avoir plusieurs adresses IP
//C'est le cas de Google
InetAddress[] addresses = InetAddress.getAllByName("google.fr");
System.out.println("\nToutes les adresses IP de google.fr : ");
for(InetAddress ad : addresses)
System.out.println(" - " + ad.getHostAddress());
addresses = InetAddress.getAllByName("google.com");
System.out.println("\nToutes les adresses IP de google.com : ");
for(InetAddress ad : addresses)
System.out.println(" - " + ad.getHostAddress());
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}

Et nous obtenons :

Récupération d'informations
Récupération d'informations

Avant de passer à la suite, je vais vous présenter certaines méthodes de l'objet InetAddress. Celles-ci retournent toutes un booléen et vous donnent des informations supplémentaires sur des adresses IP :

Méthode

Définition

isAnyLocalAddress( )

Permet de savoir si l'adresse IP est une adresse dite wildcard, c'est-à-dire qu'elle répondra à toutes les demandes sur n'importe quelle interface réseau (donc sur n'importe quelle IP). la méthode retourne donc vrai si l'adresse IP répond à ce critère.

isLoopbackAddress( )

Retourne vrai si l'adresse IP est une adresse de type boucle locale (comme 127.0.0.1).

isLinkLocalAddress( )

Retourne vrai si l'adresse est une adresse de type lien local pour le protocole IP version 6. Ce type d'adresses permet de faciliter la configuration d'IPV6.

isMulticastAddress( )

Vrai si l'adresse est dite adresse de multicast : diffuse à toutes les adresses comprises entre 224.0.0.0 et 239.255.255.255 pour IP V4 et toutes celles commençant par FF pour IP V6, mais dans un réseau local.

isMCGlobal( )

Comme la méthode isMulticastAddress(), mais à l'échelle mondiale.

isMCXXXLocal( )

En fait, toutes les méthodes commençant par isMC... concernent le multicast. Nous aurons l'occasion d'en reparler, ne vous inquiétez pas…

Encore une dernière chose : nous avons utilisé ici la classe InetAddress, mais  depuis Java 1.4, il existe deux nouvelles classes : Inet4Address et Inet6Address qui permettent de travailler directement avec des adresses en version 4 ou en version 6.

Récupérer des informations sur les adresses IP et noms d'hôtes ne devrait plus vous poser de problèmes mais avant de commencer à communiquer, nous allons utiliser une autre classe fort utile pour les ressources Internet : la classe URL.

Rappel sur Internet et la classe URL

Tout d'abord, je vais vous faire un petit rappel sur le fonctionnement d'Internet, et sa distinction avec le Web. Je ne vais pas vous faire un historique sur la naissance du Web tel que nous le connaissons maintenant, mais n'hésitez pas à consulter cet article de Wikipédia, ou cette vidéo du cours Comprendre le Web de Mathieu Nebra si vous voulez en savoir plus.

Internet est un assemblage de multiples réseaux, tous connectés entre eux. Cet amas de câbles, de fibres optiques (disons cet amas de matériel pour faire simple), constitue Internet, aussi appelé "le réseau des réseaux".

Le Web est un système de fichiers présents sur des machines (serveurs) transitant par un protocole particulier, consultables grâce à des navigateurs web et fonctionnant SUR Internet ! Le Web est donc un système de fichiers que toute personne possédant un ordinateur (ou un téléphone, maintenant...) connecté à Internet peut consulter - avec un abonnement d'un FAI (Fournisseur d'Accès à Internet), bien sûr... ^^ .

En fait, consulter les fichiers présents sur le Web est chose courante, surtout pour vous !
Eh oui ! Surfer sur le Web, aller sur OpenClassrooms, consulter vos mails chez votre FAI... tout ceci est en fait de la consultation de fichiers présents sur Internet.
Vous n'êtes pas sans savoir que, dans la majeure partie des cas, on surfe sur le Web avec un navigateur tel que Firefox, Internet Explorer, Safari... Ne vous êtes-vous jamais demandés comment les navigateurs savent aller au bon endroit ? Comme, par exemple, aller sur OpenClassrooms ?

Votre navigateur vous demande une URL saisie en "1" et, une fois cette adresse validée, votre navigateur vous renvoie ce qui se trouve à cette adresse (oui, c'est une adresse), Openclassrooms, en "2".
Il faut bien sûr que l'adresse existe et qu'il y ait quelque chose à cette adresse, sinon :

Image utilisateur

Pourquoi certaines adresses nous renvoient des pages web et d'autres des erreurs ?

Pour rappel, tout ordinateur actuel possède une adresse sur un réseau : son adresse IP.
C'est grâce à cette adresse qu'un ordinateur, ou un serveur, peut s'identifier sur un réseau. Voyez ça comme sa carte d'identité. :)
Par exemple, chez moi, je suis connecté à ma box (fournie par mon FAI) qui me donne accès à Internet.
Sur Internet, cette box a une adresse qui lui est propre et celle-ci ressemble à quelque chose comme ça : 242.231.15.123 :o. On appelle ces adresses des "adresses IP".

Lorsque vous demandez une page web à votre navigateur, vous lui demandez, de façon tacite, d'aller chercher ce qui se trouve à l'adresse demandée !

Eh ! Si les ordinateurs ont des adresses pour se reconnaître sur les réseaux, comment se fait-il qu'en tapant un nom comme "google.com" les navigateurs sachent où chercher ?

Partez du principe que toute adresse de site Internet pointe vers un serveur (ou plusieurs) qui a une adresse. Par exemple, taper "http://www.google.fr" dans votre navigateur revient à saisir "http://74.125.133.94" (adresse d'un serveur Google sur Internet) : essayez, vous verrez !
Vous êtes d'accord sur le fait que cette suite de nombres n'est pas des plus faciles à retenir...
Il est bien plus simple de mémoriser google.fr. ^^
Je ne m'éterniserai pas sur le sujet mais sachez qu'il y a une machine qui fait le lien entre les adresses de serveurs (suite de nombres) et les adresses littérales (google.fr) : les DNS. Voyez ces machines comme de gigantesques annuaires téléphoniques, mais pour les sites web. ;)

Et qu'est-ce que c'est que le "http://" ?

Si vous relisez bien ce que j'ai dit plus haut, vous vous souviendrez qu'avec l'URL que vous renseignez, vous spécifiez une machine à interroger, donc des fichiers à lire. Il ne nous manque plus que le protocole.
Ici, il s'agit du protocole http.
C'est grâce à ce protocole que le navigateur envoie des "requêtes" (nous y reviendrons) aux serveurs que vous sollicitez. Il en existe d'autres comme le FTP, le SMTP...
Inutile de nous appesantir sur le sujet (c'est un cours de programmation, pas de réseau, non mais oh !)...

Au final, une URL peut se décomposer comme suit :

Image utilisateur

Je pense que ce schéma est assez explicite... ^^
Il y a toutefois un petit détail qu'il serait bon que vous sachiez. Dans les URL, il y a un paramètre facultatif : le numéro de port utilisé par le protocole.
En fait, chaque protocole de transfert utilise un port sur le serveur, voyez ça un peu comme une porte affectée à une personne. Par exemple, lorsque vous rentrez dans une gendarmerie, vous prenez l'entrée principale (sauf si vous vous êtes fait coffrer... ^^ ), seules les personnes autorisées ont le droit de prendre l'entrée de service.

C'est la même chose pour les protocoles de transfert, chacun a un port attribué :

  • HTTP : port 80 ;

  • FTP : port 20 ou 21 ;

  • SMTP : port 25 ;

  • ...

Si nous ajoutons le numéro de port à notre URL présente dans le schéma, nous aurions ceci :
http://www.monsite.com:80/dossier/fichier.html

Mais ceci est facultatif puisque le protocole http utilise le port 80 par défaut ! ;)

La classe URL va donc pouvoir nous fournir des informations sur tout ceci ?

Pratiquement, oui. Voici un petit code qui utilise la classe URL afin de vous montrer ce que nous pouvons récupérer :

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
public class Url {
public static void main(String[] args) {
try {
URL url = new URL("http://www.google.fr");
System.out.println("Authority : " + url.getAuthority());
System.out.println("Default port : " + url.getDefaultPort());
System.out.println("Host : " + url.getHost());
System.out.println("Port : " + url.getPort());
System.out.println("Protocol : " + url.getProtocol());
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}

Ce qui me donne :

Exemple d'utilisation de l'objet URL
Exemple d'utilisation de l'objet URL

Ici, la méthode getPort() retourne -1 car le port n'est pas spécifié dans l'URL et vous pourrez remarquer que la méthode getDeafultPort(), elle, retourne bien le port 80.
Je vous propose maintenant de voir comment nous pouvons utiliser cet objet et ainsi piloter un site web sans navigateur. :)

Les classes URLConnection et HTTPUrlConnection

Ces classes vous permettent d'établir une communication entre votre application et une URL. Elles vous permettent non seulement de récupérer le contenu d'une page web mais aussi d'interagir directement avec celle-ci, contrairement à la classe URL.

La classe URLConnection est une classe abstraite qui définit des comportements globaux et la façon de travailler avec des URL. Sa classe fille la plus connue est HTTPUrlConnection qui permet de dialoguer avec des applications web via le protocole HTTP.

Nous n'allons pas faire d'application client / serveur ?

Si, bien sûr mais, avant de voir le côté complexe de ce type d'applications, nous allons voir comment s'amuser un peu avec un serveur déjà opérationnel. :)
Je vous propose de vous montrer comment interagir avec un site web grâce à Java (c'est l'équivalent de la librairie CURL pour PHP).

Alors, comment les choses vont se passer :

  1. Nous allons utiliser la méthode openConnection() de notre objet URL : celle-ci nous retourne un objet de type URLConnection ;

  2. Grâce à cet objet, nous allons pouvoir interagir avec notre ressource : récupérer des données mais aussi lui en envoyer ;

  3. Nous allons récupérer les interactions grâce à la méthode getInputStream() de notre objet URLConnection ;

  4. Nous stockerons le résultat dans une chaîne de caractères ;

  5. Nous l'afficherons dans notre programme grâce à un composant JavaFX (pas encore très au point mais tout de même beaucoup mieux qu'un JEditorPane…).

Avant de poursuivre, je vous fournis le code source de ma classe Browser, qui affiche le rendu HTML de notre programme :

package URL;
import java.awt.Dimension;
import javafx.application.Platform;
import javafx.embed.swing.JFXPanel;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.web.WebEngine;
import javafx.scene.web.WebView;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
public class Browser extends JFrame{
JFXPanel fxPanel = new JFXPanel();
//Les composants JavaFX
Group group;
Scene scene;
WebView webView;
WebEngine webEngine;
FXRunnable fxRun;
final int WIDTH=900, HEIGHT=600;
public Browser(String title, final String content){
//On initialise notre fenêtre
setSize(new Dimension(WIDTH,HEIGHT));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setTitle(title);
add(new JScrollPane(fxPanel));
setVisible(true);
//pour mélanger des composants JavaFX et Swing
//les composants JavaFX doivent s'exécuter dans leur propre thread
//Ils ne s'exécutent pas dans l'EDT swing !
fxRun = new FXRunnable(content);
//Lance le thread dans un thread dédié à JavaFX
Platform.runLater(fxRun);
}
/**
* Méthode permettant de mettre à jour le JFXPanel
* @param content
*/
public void setContent(String content){
//pour la mise à jour de ce composant,
//vu qu'il cohabite avec Swing
//celle-ci DOIT se faire dans un thread JavaFX
fxRun = new FXRunnable(content);
Platform.runLater(fxRun);
}
/**
* une classe interne qui permet de travailler conjointement
* avec JavaFX et Swing
* @author CHerby
*/
private class FXRunnable implements Runnable{
String content;
public FXRunnable(String pContent){
content = pContent;
}
public void run(){
initFX(fxPanel);
setContent(content);
}
/**
* initialise les composants JavaFX
* @param fxPanel
*/
private void initFX(JFXPanel fxPanel){
group = new Group();
scene = new Scene(group);
fxPanel.setScene(scene);
webView = new WebView();
webEngine = webView.getEngine();
group.getChildren().add(webView);
webView.setMinSize(WIDTH, HEIGHT);
webView.setMaxSize(WIDTH, HEIGHT);
}
public void setContent(String content){
webEngine.loadContent(content);
webEngine.reload();
}
}
}

Pour pouvoir avoir accès aux composants JavaFX dans un projet Java, vous devez avoir la dernière version du JDK, moi j'ai le JDK 7 update 25 au moment où j'écris ces lignes. JavaFX est embarqué dans cette version mais, si vous l'utilisez dans Eclipse, les composants JavaFX ne sont pas automatiquement importés. Pour pouvoir y avoir accès, voici la marche à suivre :

1 - Téléchargez le JDK 7

Pour télécharger le JDK-7, je vous invite à consulter la procédure que j'ai décrite dans mon cours "Apprenez à programmer en Java". Les étapes sont exactement les mêmes, sauf que vous allez télécharger et installer le JDK au lieu du JRE.

2 - Configurez Eclipse

Il faudra, si vous ne travailliez pas avec la dernière version du JDK, configurer Eclipse pour votre projet. Pour ce faire, nous allons faire un clic-droit sur celui-ci et choisir l'option ci-dessous :

Build Path
Build Path

Pour que vous compreniez mieux, j'ai supprimé tous mes environnements d'Eclipse, il n'y a donc rien chez moi mais ce ne sera peut-être pas le cas chez vous… Cliquez maintenant sur le bouton ci-dessous :

Build Path
Build Path

Sélectionnez le type de librairie que vous souhaitez configurer, ici, c'est un environnement Java :

Image utilisateur

Sur la popup suivante, cliquez sur le bouton "Installed JRE" :

Image utilisateur

Ici, vous pouvez voir que j'ai déjà un JRE d'installé, mais pas le dernier, on clique alors sur "Add" :

Image utilisateur

On sélectionne "Standard JVM" car nous allons importer une machine virtuelle :

Image utilisateur

On clique maintenant sur le bouton "Directory" :

Image utilisateur

Et on choisit notre environnement à importer. Chez moi, il se trouve dans C:\Programmes\Java.

Image utilisateur

Validez toutes les popups ouvertes et cochez le JRE à utiliser pour votre projet dans la fenêtre ci-dessous :

Image utilisateur

Voilà, vous utilisez maintenant le dernier JRE pour ce programme.

3 - Ajoutez JavaFX

Maintenant, comme je vous le disais plus haut, si vous travaillez avec Java 7, JavaFX ne sera pas automatiquement importé dans votre projet. Pour faire cela, nous allons devoir importer le fichier .jar où se trouvent tous les composants dont nous allons avoir besoin. Ce dernier se nomme jfxrt.jar.
Refaites la première étape vue ci-dessus : clic-droit sur votre projet…
Ensuite, cliquez sur le bouton "Add External Jar" :

Image utilisateur

Rendez-vous maintenant dans le dossier "lib" concerné :

Image utilisateur

Et voilà, vous pouvez maintenant utiliser des composants JavaFX avec swing !

Image utilisateur

Bon, retournons à nos moutons. Voici le code que j'ai utilisé pour naviguer, sans mon navigateur, sur le site d'Oracle dédié à la recherche de ressources sur leurs site :

package URL;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
public class Url {
public static void main(String[] args) {
try {
String siteWeb = "http://search.oracle.com//search/search";
URL url = new URL(siteWeb);
System.out.println("Authority : " + url.getAuthority());
System.out.println("Default port : " + url.getDefaultPort());
System.out.println("Host : " + url.getHost());
System.out.println("Port : " + url.getPort());
System.out.println("Protocol : " + url.getProtocol());
try {
//Nous nous connectons au site en question
URLConnection urlConn = url.openConnection();
System.out.println(urlConn.getContentType());
String content = "", line = null;
//Nous récupérons un flux en retour de connexion
BufferedReader buf = new BufferedReader(new InputStreamReader(urlConn.getInputStream()));
//Nous stockons les informations retournées dans une chaîne de caractères
while((line = buf.readLine()) != null){
content += line + "\n";
}
//Nous instancions notre objet pour afficher le contenu
Browser browser = new Browser("Google",content);
//Et nous faisons une recherche sur ce même site
String result = makeSearch(siteWeb, "java");
//Nous mettons à jour notre page
browser.setContent(result);
//Et nous faisons une recherche sur ce même site
result = makeSearch(siteWeb, "java.net package & RMI");
//Nous mettons à jour notre page
browser.setContent(result);
} catch (IOException e) {
e.printStackTrace();
}
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
public static String makeSearch(String url, String search){
//Une petite pause
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
String resultat = "";
HttpURLConnection con = null;
try {
//Cette classe permet d'encoder les caractères spéciaux
//pour qu'ils soient interprétables dans une URL
//Nous devons fournir la chaîne à encoder et le type d'encodage, ici UTF-8
String recherche = URLEncoder.encode("q", "UTF-8") + "=";
recherche += URLEncoder.encode(search, "UTF-8");
//Nous nous connectons, via un objet HTTPUrlConnection
//à la nouvelle URL, la recherche se faisant en GET,
//les paramètres sont dans l'URL
System.out.println("URL de recherche : " + url + "?" + recherche);
con = (HttpURLConnection) new URL(url + "?" + recherche).openConnection();
//Comme la recherche précédente, nous récupérons un flux que nous allons stocker
BufferedReader rd = new BufferedReader(new InputStreamReader(con.getInputStream()));
String line;
while ((line = rd.readLine()) != null) {
resultat += line + "\n";
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (ProtocolException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return resultat;
}
}

Ce code affiche donc une première page, la fameuse page de recherche d'Oracle :

Page d'accueil
Page d'accueil

Ensuite, après 5 secondes d'attente, nous lançons une première recherche sur le terme "java" sur ce site, ce qui nous donne :

Après l'envoi de la recherche
Après l'envoi de la recherche

Et encore après 5 secondes d'attente, j'envoie une seconde recherche :

Après l'envoi de la seconde recherche
Après l'envoi de la seconde recherche

Vous remarquerez que la seconde recherche comprend certains caractères spéciaux qui sont encodés avant leur envoi, comme le montre l'image ci-dessous :

Encodage d'URL
Encodage d'URL

Ici nous avons utilisé une communication via la méthode GET, donc en passant les paramètres directement dans l'URL. Ces objets vous permettent aussi de faire des requêtes en utilisant la méthode POST, où les données ne seront plus dans l'URL mais dans les entêtes HTTP où il y a beaucoup plus de place disponible. :)

Pour faire une requête de type POST, voici comment procéder :

con = (HttpURLConnection) new URL(url).openConnection();
//On spécifie le type de méthode car, par défaut le type est GET
con.setRequestMethod("POST");
//Pour pouvoir écrire dans l'entête, nous devons l'autoriser
con.setDoOutput(true);
con.setRequestProperty("x-forwarded-for", "on change un paramètre de l'entête HTTP");

Voilà, vous avez fait vos premières armes, nous allons maintenant passer à la vitesse supérieure. :)

Je vous l'avais dit, rien de compliqué ici. Maintenant que vous savez comment récupérer des adresses et toutes sortes d'informations sur des hôtes, nous allons voir comment nous servir de tout ceci, mais avant, un petit TP pour se familiariser avec l'objet InetAddress.

Example of certificate of achievement
Example of certificate of achievement