Java Academy · Leçon

Corps et en-têtes des requêtes

Envoyez des données POST et définissez les en-têtes

Corps et en-têtes des requêtes est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Corps et en-têtes des requêtes

Les requêtes GET nécessitent rarement un corps, mais les requêtes POST, PUT et PATCH en ont besoin. Le client HTTP du JDK utilise des objets BodyPublisher pour fournir les corps des requêtes et des méthodes du générateur pour définir les en-têtes.

Cette leçon présente l’envoi de données et le contrôle d’en-têtes comme Content-Type.

BodyPublishers.ofString

Le producteur le plus simple envoie un corps sous forme de chaîne. Transmettez-le à la méthode POST(...) du générateur de requête.

BodyPublishers.noBody() est prévu pour les requêtes sans corps.

import java.net.URI;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;

public class Main {
    public static void main(String[] args) {
        String json = "{\"name\":\"Ada\"}";
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/users"))
            .POST(BodyPublishers.ofString(json))
            .build();
        System.out.println("Method: " + request.method());
    }
}

Définir un seul en-tête

Utilisez header(name, value) pour ajouter un en-tête. Pour envoyer du JSON, vous définissez presque toujours Content-Type.

import java.net.URI;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;

public class Main {
    public static void main(String[] args) {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/users"))
            .header("Content-Type", "application/json")
            .POST(BodyPublishers.ofString("{}"))
            .build();
        System.out.println("Has Content-Type: " +
            request.headers().firstValue("Content-Type").isPresent());
    }
}

Plusieurs en-têtes à la fois

headers(name1, value1, name2, value2, ...) définit plusieurs en-têtes en un seul appel. Le nombre d’arguments doit être pair, sinon IllegalArgumentException est levée.

import java.net.URI;
import java.net.http.HttpRequest;

public class Main {
    public static void main(String[] args) {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .headers(
                "Accept", "application/json",
                "Accept-Language", "en-US")
            .GET()
            .build();
        System.out.println(request.headers().map().keySet());
    }
}

En-têtes d’autorisation

Les jetons Bearer sont envoyés via l’en-tête Authorization. Construisez la valeur sous forme de chaîne ; ne consignez jamais le jeton brut.

public class Main {
    public static void main(String[] args) {
        String token = "abc123";
        String headerValue = "Bearer " + token;
        System.out.println("Authorization: Bearer ***");
        System.out.println("Length: " + headerValue.length());
    }
}

PUT et DELETE

Le générateur possède des méthodes dédiées : PUT(publisher), DELETE() et la méthode générique method(name, publisher) pour tout autre verbe, comme PATCH.

import java.net.URI;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;

public class Main {
    public static void main(String[] args) {
        HttpRequest patch = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/users/1"))
            .method("PATCH", BodyPublishers.ofString("{\"active\":true}"))
            .build();
        System.out.println("Method: " + patch.method());
    }
}

Corps encodés par formulaire

Pour les données application/x-www-form-urlencoded, construisez manuellement la chaîne du corps, encodez chaque valeur pour l’URL, puis publiez-la sous forme de chaîne.

import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) {
        String body = "name=" + URLEncoder.encode("Ada Lovelace", StandardCharsets.UTF_8)
            + "&role=" + URLEncoder.encode("engineer", StandardCharsets.UTF_8);
        System.out.println(body);
    }
}

Envoyer un corps provenant d’un fichier

BodyPublishers.ofFile(path) diffuse un fichier comme corps de la requête sans le charger entièrement en mémoire — idéal pour les téléversements.

import java.net.URI;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/upload"))
            .header("Content-Type", "application/octet-stream")
            .POST(BodyPublishers.ofFile(Path.of("data.bin")))
            .build();
        System.out.println("Upload request built");
    }
}

Corps sous forme de tableaux d’octets

Lorsque vous avez déjà des octets en mémoire, BodyPublishers.ofByteArray(byte[]) les envoie directement. Cette méthode est utile pour les charges utiles binaires créées à l’exécution.

import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) {
        byte[] payload = "raw-bytes".getBytes(StandardCharsets.UTF_8);
        // BodyPublishers.ofByteArray(payload) would wrap these bytes
        System.out.println("Payload size: " + payload.length + " bytes");
    }
}

En-têtes restreints

Pour des raisons de sécurité, le client vous interdit de définir certains en-têtes, comme Host, Content-Length, Connection et Upgrade. Toute tentative de les définir lève une IllegalArgumentException — le client les gère lui-même.

Tout assembler

Un POST JSON typique associe un producteur de corps et un en-tête de type de contenu :

.POST(BodyPublishers.ofString(json))
.header("Content-Type", "application/json")
add .header("Authorization", "Bearer ...") si nécessaire

Vérification rapide

Vérifiez votre compréhension des corps et des en-têtes de requête.

Récapitulatif

Vous avez appris à envoyer des données et à contrôler les en-têtes :

BodyPublishers.ofString / ofByteArray / ofFile fournissent les corps des requêtes.
POST / PUT / DELETE / method(...) choisissent le verbe HTTP.
header(...) et headers(...) définissent les en-têtes des requêtes.
Définissez Content-Type pour les données JSON et les données de formulaire ; utilisez Authorization pour les jetons.
Certains en-têtes (Host, Content-Length) sont restreints et gérés par le client.

Questions Fréquemment Posées

La leçon « Corps et en-têtes des requêtes » est-elle gratuite ?

Oui — le texte complet de « Corps et en-têtes des requêtes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Corps et en-têtes des requêtes » ?

Envoyez des données POST et définissez les en-têtes Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Corps et en-têtes des requêtes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Java Academy