Fondamentaux des méthodes HTTP : GET et POST

Le protocole HTTP repose sur plusieurs méthodes pour interagir avec les ressources réseau. Les deux plus courantes, GET et POST, possèdent des caractéristiques distinctes qu'il est crucial de maîtriser pour le développement d'applications Java.

La méthode GET transmet les paramètres directement dans l'URL, après un point d'interrogation, en les séparant par des esperluettes. Les données sont encodées en URL (par exemple, les espaces deviennent des + et les caractères spéciaux sont convertis en format hexadécimal). Bien que le protocole lui-même n'impose pas de limite stricte, les navigateurs et les serveurs restreignent souvent la longueur de l'URL (généralement autour de 2 Ko). GET est idempotent et conçu pour la récupération de données, mais il est déconseillé pour les informations sensibles en raison de l'exposition dans l'historique et les logs.

À l'inverse, POST encpasule les paramètres dans le corps de la requête. Cette approche n'est pas soumise aux limites de longueur des URL, ce qui la rend idéale pour le transfert de volumes de données importants ou de fichiers. De plus, elle offre une meilleure confidentialité pour les données sensibles, bien qu'elle nécessite tout de même l'utilistaion de HTTPS pour un chiffrement complet.

Approche native : HttpURLConnection

Inclus dans le package java.net du JDK, HttpURLConnection est l'outil standard pour effectuer des appels HTTP sans dépendances externes. Il fournit un contrôle granulaire sur la connexion, mais nécessite une gestion manuelle des flux et des états.

Exécution d'une requête GET native

package fr.tech.network;

import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URI;
import java.nio.charset.StandardCharsets;

public class NativeGetExecutor {

    public static void main(String[] args) {
        try {
            URI targetUri = new URI("https://api.example.com/v1/users?role=admin&status=active");
            HttpURLConnection httpConn = (HttpURLConnection) targetUri.toURL().openConnection();

            httpConn.setRequestMethod("GET");
            httpConn.setConnectTimeout(5000);
            httpConn.setReadTimeout(5000);
            httpConn.setRequestProperty("Accept", "application/json");

            int statusCode = httpConn.getResponseCode();
            if (statusCode == HttpURLConnection.HTTP_OK) {
                try (InputStream responseStream = httpConn.getInputStream()) {
                    String responseBody = new String(responseStream.readAllBytes(), StandardCharsets.UTF_8);
                    System.out.println("Données récupérées : " + responseBody);
                }
            } else {
                System.err.println("Échec de la requête. Code HTTP : " + statusCode);
            }
            httpConn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Exécution d'une requête POST native

package fr.tech.network;

import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URI;
import java.nio.charset.StandardCharsets;

public class NativePostExecutor {

    public static void main(String[] args) {
        try {
            URI endpoint = new URI("https://api.example.com/v1/auth/login");
            HttpURLConnection httpConn = (HttpURLConnection) endpoint.toURL().openConnection();

            httpConn.setRequestMethod("POST");
            httpConn.setDoOutput(true);
            httpConn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            httpConn.setConnectTimeout(5000);

            String payload = "user_id=dev_01&access_token=secret_key_99";

            try (OutputStream os = httpConn.getOutputStream()) {
                byte[] input = payload.getBytes(StandardCharsets.UTF_8);
                os.write(input, 0, input.length);
            }

            int responseCode = httpConn.getResponseCode();
            System.out.println("Code de statut POST : " + responseCode);
            httpConn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Particularités techniques de HttpURLConnection

• L'instanciation se fait exclusivement via URL.openConnection().
• L'appel à connect() est souvent implicite ; la connexion TCP et l'envoi de la requête sont déclenchés lors de l'appel à getInputStream() ou getResponseCode().
• La configuration des en-têtes et des timeouts doit impérativement précéder toute tentative de lecture ou d'écriture.
• Les données du corps POST sont bufferisées en mémoire avant d'être flushées vers le réseau lors de la fermeture du flux de sortie.

Approche avancée : Apache HttpClient

Bien que la solution native soit adéquate pour des cas simples, elle montre ses limites face à des scénarios complexes impliquant la gestion des cookies, le maintien de sessions, l'authentification ou les pools de connexions. Apache HttpClient comble ces lacunes en offrant une API de haut niveau, robuste et hautement configurable, spécialement conçue pour agir en tant que client HTTP complet.

Exécution d'une requête GET avec HttpClient

package fr.tech.network;

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class ApacheGetExecutor {

    public static void main(String[] args) {
        try (CloseableHttpClient client = HttpClients.createDefault()) {
            HttpGet request = new HttpGet("https://api.example.com/v1/products?category=electronics");

            try (CloseableHttpResponse response = client.execute(request)) {
                System.out.println("Statut : " + response.getStatusLine().getStatusCode());
                String content = EntityUtils.toString(response.getEntity(), "UTF-8");
                System.out.println("Contenu de la réponse : " + content);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Exécution d'une requête POST avec HttpClient

package fr.tech.network;

import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.List;

public class ApachePostExecutor {

    public static void main(String[] args) {
        try (CloseableHttpClient client = HttpClients.custom().build()) {
            HttpPost postRequest = new HttpPost("https://api.example.com/v1/orders");

            List<basicnamevaluepair> formData = Arrays.asList(
                    new BasicNameValuePair("item_id", "PROD-8832"),
                    new BasicNameValuePair("quantity", "3")
            );

            postRequest.setEntity(new UrlEncodedFormEntity(formData, StandardCharsets.UTF_8));

            try (CloseableHttpResponse response = client.execute(postRequest)) {
                String result = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
                System.out.println("Résultat de la commande : " + result);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
</basicnamevaluepair>

Avantages de l'abstraction Apache

L'utilisation d'Apache HttpClient élimine la nécessité de gérer manuellement les flux d'entrée et de sortie de bas niveau. La bibliothèque prend en charge nativement la serialization des paramètres de formulaire, la gestion automatique des redirections, et l'intégration fluide avec les contextes d'exécution pour le suivi des états (comme les cookies). De plus, l'utilisation systématique de l'interface Closeable garantit une libération optimale des ressources réseau grâce aux blocs try-with-resources.