Java Academy · Lección

Solicitudes asíncronas

sendAsync y CompletableFuture

Solicitudes asíncronas es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 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.

Solicitudes asíncronas

Bloquearse en cada llamada HTTP desperdicia subprocesos. El cliente HTTP del JDK ofrece sendAsync, que devuelve inmediatamente un CompletableFuture y realiza el trabajo en un executor en segundo plano.

Esto permite enviar muchas solicitudes de forma simultánea y combinar sus resultados sin administrar los subprocesos manualmente.

send frente a sendAsync

Las firmas se diferencian por el valor que devuelven:

send devuelve HttpResponse<T> y bloquea, declarando IOException y InterruptedException.
sendAsync devuelve CompletableFuture<HttpResponse<T>> y nunca bloquea; los errores se manifiestan a través del future.

Una llamada básica a sendAsync

sendAsync recibe la misma solicitud y el mismo BodyHandler que send. El future devuelto se completa cuando la respuesta está lista.

import java.net.URI;
import java.net.http.*;
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .build();
        CompletableFuture<HttpResponse<String>> future =
            client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Request sent, future created");
    }
}

Transformación con thenApply

Use thenApply para transformar el resultado cuando llegue; por ejemplo, para extraer el cuerpo de la respuesta.

Esto se ejecuta de forma síncrona en el subproceso que haya completado la etapa anterior.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) throws Exception {
        CompletableFuture<String> future =
            CompletableFuture.completedFuture("OK 200")
                .thenApply(body -> "Length=" + body.length());
        System.out.println(future.get());
    }
}

Consumo con thenAccept

Cuando solo quiere realizar un efecto secundario y no devolver ningún valor, use thenAccept. Recibe un Consumer y produce un CompletableFuture<Void>.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) throws Exception {
        CompletableFuture<Void> done =
            CompletableFuture.completedFuture("payload")
                .thenAccept(b -> System.out.println("Received: " + b));
        done.get();
    }
}

Bloqueo con join

Para esperar un resultado asíncrono desde main, llame a join() (no comprobada) o a get() (comprobada). En un servidor real, encadenaría etapas en lugar de bloquear.

join() envuelve los fallos en una CompletionException no comprobada.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<Integer> f =
            CompletableFuture.supplyAsync(() -> 21).thenApply(n -> n * 2);
        int result = f.join();
        System.out.println("Result: " + result);
    }
}

Gestión de errores con exceptionally

exceptionally proporciona un valor alternativo cuando falla una etapa, lo que permite recuperar el flujo.

Así puede evitar que un flujo HTTP asíncrono se detenga ante un error de red.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> f = CompletableFuture
            .<String>supplyAsync(() -> { throw new RuntimeException("boom"); })
            .exceptionally(ex -> "fallback: " + ex.getMessage());
        System.out.println(f.join());
    }
}

Combinación de dos solicitudes

thenCombine espera dos futures independientes y combina sus resultados. Con HTTP asíncrono, permite obtener dos endpoints en paralelo y unir sus cuerpos.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> "Hello");
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> "World");
        String combined = a.thenCombine(b, (x, y) -> x + " " + y).join();
        System.out.println(combined);
    }
}

Ejecución de muchas solicitudes en paralelo

Para ejecutar un conjunto de solicitudes, recopile cada future en una lista y use después CompletableFuture.allOf(...) para esperar a que terminen todas.

allOf devuelve CompletableFuture<Void>; después debe leer los resultados individuales.

import java.util.*;
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        List<CompletableFuture<Integer>> futures = new ArrayList<>();
        for (int i = 1; i <= 3; i++) {
            int n = i;
            futures.add(CompletableFuture.supplyAsync(() -> n * n));
        }
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
        for (var f : futures) System.out.println(f.join());
    }
}

Resumen del patrón asíncrono

Un flujo HTTP asíncrono típico tiene este aspecto:

client.sendAsync(req, BodyHandlers.ofString())
.thenApply(HttpResponse::body) para obtener el cuerpo
.thenAccept(System.out::println) para consumirlo
.exceptionally(ex -> ...) para recuperarse

Nunca se bloquea ningún subproceso mientras espera la red.

Cuándo usar asincronía

Elija sendAsync cuando realice muchas llamadas simultáneas, distribuya solicitudes entre varios servicios o trabaje dentro de un servidor reactivo o no bloqueante. Elija send para scripts sencillos y llamadas puntuales en las que bloquear no suponga un problema.

Comprobación rápida

Compruebe cuánto ha entendido de las solicitudes asíncronas.

Resumen

Ha aprendido a realizar llamadas HTTP no bloqueantes:

sendAsync devuelve un CompletableFuture en lugar de bloquear.
thenApply / thenAccept transforman y consumen el resultado.
exceptionally proporciona un valor alternativo en caso de error.
thenCombine combina dos llamadas paralelas; allOf espera a que termine un conjunto.
La asincronía es adecuada para servidores de alta concurrencia y reactivos; la sincronía, para scripts sencillos.

Preguntas frecuentes

¿La lección «Solicitudes asíncronas» es gratis?

Sí — el texto completo de «Solicitudes asíncronas» 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 «Solicitudes asíncronas»?

sendAsync y CompletableFuture 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 2 de 4.

¿Cuánto tiempo toma la lección «Solicitudes asíncronas»?

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