Java Academy · Lección

java.net.http.HttpClient

Envíe solicitudes síncronas

java.net.http.HttpClient es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 1 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.

El cliente HTTP moderno

Desde Java 11, el JDK incluye un cliente HTTP moderno en el paquete java.net.http. Sustituye al antiguo HttpURLConnection por una API clara y fluida compatible con HTTP/1.1 y HTTP/2.

Los tres tipos principales son:

HttpClient — envía solicitudes y administra la configuración (tiempos de espera, proxies y redirecciones).
HttpRequest — descripción inmutable de lo que se enviará.
HttpResponse — resultado que incluye el estado, las cabeceras y el cuerpo.

Crear un HttpClient

Puede crear un cliente mediante el método estático newBuilder(). Un único cliente puede reutilizarse para muchas solicitudes y es seguro para utilizarse desde varios hilos.

Aquí se configuran HTTP/2 y un tiempo de espera de conexión. También está disponible newHttpClient() para crear rápidamente una instancia con la configuración predeterminada.

import java.net.http.HttpClient;
import java.time.Duration;

public class Main {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(10))
            .build();
        System.out.println("Client version: " + client.version());
    }
}

Construcción de una solicitud

HttpRequest es inmutable y se construye mediante un builder fluido. Como mínimo, debe proporcionar un URI; de forma predeterminada, realiza una solicitud GET.

Puede convertir una cadena en un URI mediante URI.create(...).

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/data"))
            .GET()
            .build();
        System.out.println("Method: " + request.method());
        System.out.println("URI: " + request.uri());
    }
}

Envío síncrono

El método send bloquea el subproceso que lo invoca hasta que llega la respuesta. Necesita un BodyHandler que indique al cliente cómo interpretar el cuerpo de la respuesta.

BodyHandlers.ofString() lee el cuerpo en un String.

import java.net.URI;
import java.net.http.*;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .build();
        HttpResponse<String> response =
            client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Status: " + response.statusCode());
    }
}

Lectura del código de estado

La respuesta expone statusCode() como un int. Los códigos del intervalo 2xx indican éxito, los 3xx son redirecciones, los 4xx son errores del cliente y los 5xx son errores del servidor.

Nota: el cliente HTTP nunca lanza una excepción ante una respuesta 4xx/5xx; debe comprobar el código por su cuenta.

public class Main {
    public static void main(String[] args) {
        int status = 404;
        String label;
        if (status >= 200 && status < 300) label = "Success";
        else if (status >= 300 && status < 400) label = "Redirect";
        else if (status >= 400 && status < 500) label = "Client error";
        else label = "Server error";
        System.out.println(status + " -> " + label);
    }
}

Lectura del cuerpo

Con BodyHandlers.ofString(), response.body() devuelve un String. También existen otros handlers para bytes, archivos y streams (que se tratarán más adelante).

Este fragmento simula el contenido del cuerpo que recibiría.

public class Main {
    public static void main(String[] args) {
        String body = "{\"message\":\"hello\"}";
        System.out.println("Body length: " + body.length());
        System.out.println("Body: " + body);
    }
}

Gestión de redirecciones

De forma predeterminada, el cliente no sigue las redirecciones. Puede configurarlo en el builder mediante followRedirects(...).

Las opciones de HttpClient.Redirect son NEVER, ALWAYS y NORMAL (sigue las redirecciones excepto las degradaciones de HTTPS a HTTP).

import java.net.http.HttpClient;

public class Main {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
            .followRedirects(HttpClient.Redirect.NORMAL)
            .build();
        System.out.println("Redirect policy: " + client.followRedirects());
    }
}

Tiempo de espera por solicitud

El tiempo de espera de conexión pertenece al cliente. El tiempo de espera de una solicitud (cuánto esperar una respuesta) pertenece a la solicitud y se establece mediante timeout(...).

Si transcurre ese tiempo, send lanza una HttpTimeoutException.

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

public class Main {
    public static void main(String[] args) {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .timeout(Duration.ofSeconds(5))
            .build();
        System.out.println("Timeout set: " + request.timeout().isPresent());
    }
}

Inspección de los encabezados de respuesta

La respuesta contiene un objeto HttpHeaders accesible mediante headers(). Las búsquedas de encabezados no distinguen entre mayúsculas y minúsculas y pueden devolver varios valores, por lo que firstValue(...) devuelve un Optional<String>.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        // Simulating a header lookup result
        Optional<String> contentType = Optional.of("application/json");
        System.out.println("Content-Type: " + contentType.orElse("unknown"));
    }
}

Excepciones comprobadas

El método síncrono send declara dos excepciones comprobadas:

IOException — error de red o de protocolo.
InterruptedException — se interrumpió el subproceso bloqueado.

Debe capturar o declarar ambas. Las llamadas asíncronas (en la siguiente lección) evitan esto porque devuelven un future.

import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try {
            // client.send(...) would go here
            throw new IOException("connection refused");
        } catch (IOException e) {
            System.out.println("Network problem: " + e.getMessage());
        }
    }
}

Un cliente reutilizable

Práctica recomendada: cree un solo HttpClient y reutilícelo en toda la aplicación. Agrupa las conexiones y es completamente seguro para subprocesos.

Crear un cliente nuevo para cada solicitud desperdicia recursos e impide aprovechar la multiplexación de HTTP/2.

import java.net.http.HttpClient;

public class Main {
    private static final HttpClient SHARED = HttpClient.newHttpClient();

    public static void main(String[] args) {
        System.out.println("Shared client ready: " + (SHARED != null));
    }
}

Comprobación rápida

Compruebe cuánto ha entendido del cliente HTTP síncrono.

Resumen

Ha aprendido los conceptos básicos del cliente HTTP del JDK:

HttpClient.newBuilder() configura la versión, el tiempo de espera y las redirecciones; reutilice una sola instancia.
HttpRequest.newBuilder().uri(...).GET() construye una solicitud inmutable.
client.send(request, BodyHandlers.ofString()) bloquea y devuelve un HttpResponse<String>.
Lea los resultados con statusCode(), body() y headers().
Los códigos que no son 2xx no lanzan excepciones; debe comprobarlos por su cuenta.

Preguntas frecuentes

¿La lección «java.net.http.HttpClient» es gratis?

Sí — el texto completo de «java.net.http.HttpClient» 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 «java.net.http.HttpClient»?

Envíe solicitudes síncronas 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 1 de 4.

¿Cuánto tiempo toma la lección «java.net.http.HttpClient»?

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