Java Academy · Lección

Cuerpos y encabezados de solicitudes

Envíe datos POST y establezca encabezados

Cuerpos y encabezados de solicitudes es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Cuerpos y encabezados de las solicitudes

Las solicitudes GET rara vez necesitan un cuerpo, pero POST, PUT y PATCH sí lo necesitan. El cliente HTTP del JDK utiliza objetos BodyPublisher para proporcionar cuerpos de solicitud y métodos del builder para establecer encabezados.

Esta lección explica cómo enviar datos y controlar encabezados como Content-Type.

BodyPublishers.ofString

El publisher más sencillo envía un cuerpo de tipo cadena. Páselo al método POST(...) del builder de la solicitud.

BodyPublishers.noBody() existe para las solicitudes sin cuerpo.

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

Establecimiento de un solo encabezado

Use header(name, value) para añadir un encabezado. Para enviar JSON, casi siempre debe establecer 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());
    }
}

Varios encabezados a la vez

headers(name1, value1, name2, value2, ...) establece varios encabezados en una sola llamada. El número de argumentos debe ser par; de lo contrario, lanza IllegalArgumentException.

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

Encabezados de autorización

Los tokens Bearer se envían mediante el encabezado Authorization. Construya el valor como una cadena; nunca registre el token sin ocultar.

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 y DELETE

El builder tiene métodos específicos: PUT(publisher), DELETE() y el método genérico method(name, publisher) para cualquier otro verbo, como 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());
    }
}

Cuerpos codificados como formularios

Para datos application/x-www-form-urlencoded, debe construir manualmente la cadena del cuerpo, codificando cada valor para URL, y después publicarla como una cadena.

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

Envío de un archivo como cuerpo

BodyPublishers.ofFile(path) transmite un archivo como cuerpo de la solicitud sin cargarlo por completo en memoria; es ideal para las cargas de archivos.

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");
    }
}

Cuerpos de matrices de bytes

Cuando ya tiene bytes en memoria, BodyPublishers.ofByteArray(byte[]) los envía directamente. Resulta útil para cargas binarias construidas en tiempo de ejecución.

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");
    }
}

Encabezados restringidos

Por motivos de seguridad, el cliente no permite establecer determinados encabezados, como Host, Content-Length, Connection y Upgrade. Si intenta establecerlos, se lanza IllegalArgumentException; el cliente los administra por su cuenta.

Integración de todos los elementos

Una solicitud POST típica con JSON combina un publisher de cuerpo y un encabezado de tipo de contenido:

.POST(BodyPublishers.ofString(json))
.header("Content-Type", "application/json")
añada .header("Authorization", "Bearer ...") si es necesario

Comprobación rápida

Compruebe cuánto ha entendido de los cuerpos y encabezados de las solicitudes.

Resumen

Ha aprendido a enviar datos y controlar encabezados:

BodyPublishers.ofString / ofByteArray / ofFile proporcionan cuerpos de solicitud.
POST / PUT / DELETE / method(...) seleccionan el verbo HTTP.
header(...) y headers(...) establecen los encabezados de la solicitud.
Establezca Content-Type para JSON y datos de formularios; use Authorization para los tokens.
Algunos encabezados (Host, Content-Length) están restringidos y los administra el cliente.

Preguntas frecuentes

¿La lección «Cuerpos y encabezados de solicitudes» es gratis?

Sí — el texto completo de «Cuerpos y encabezados de solicitudes» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Cuerpos y encabezados de solicitudes»?

Envíe datos POST y establezca encabezados Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Cuerpos y encabezados de solicitudes»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy