0Pricing
Java Academy · Lección

Gestión de errores y canalización HTTP asíncrona

Gestione errores con exceptionally, handle y whenComplete, y después cree una canalización de cliente HTTP asíncrona.

Gestión de errores y canalización HTTP asíncrona es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 4 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.

Por qué es importante gestionar los errores asíncronos

En las canalizaciones asíncronas, las excepciones no se propagan igual que en el código síncrono. Debe gestionar los errores explícitamente mediante exceptionally, handle o whenComplete.

exceptionally: Recuperación de errores

exceptionally(Function<Throwable, T>) solo se llama si el future se completa con una excepción. Proporciona un valor alternativo que mantiene activo el flujo.

CompletableFuture<String> safe = fetchUser(id)
    .thenApply(User::getName)
    .exceptionally(ex -> {
        log.warn("Fetch failed: " + ex.getMessage());
        return "Anonymous";
    });
System.out.println(safe.join()); // "Anonymous" if fetch failed

handle: Transformación del éxito y el fallo

handle(BiFunction<T, Throwable, U>) se llama tanto en caso de éxito como de fallo. Uno de los dos argumentos será null.

fetchUser(id).handle((user, ex) -> {
    if (ex != null) return UserDto.empty();
    return UserDto.from(user);
}).thenAccept(dto -> sendResponse(dto));

whenComplete: Efecto secundario tras cualquier resultado

whenComplete(BiConsumer) se llama una vez completada la operación, independientemente del resultado. No cambia el resultado; utilícelo para el registro, las métricas o la limpieza.

fetchUser(id)
    .whenComplete((user, ex) -> {
        if (ex != null) metrics.increment("user.fetch.error");
        else            metrics.increment("user.fetch.success");
    })
    .thenAccept(u -> sendResponse(u));

Reintento de futures fallidos

Implemente la lógica de reintentos llamando recursivamente a la operación cuando falle, hasta alcanzar un número máximo de intentos.

CompletableFuture<String> withRetry(Supplier<CompletableFuture<String>> task, int retries) {
    return task.get().exceptionallyCompose(ex -> {
        if (retries > 0) {
            System.out.println("Retrying... " + retries);
            return withRetry(task, retries - 1);
        }
        return CompletableFuture.failedFuture(ex);
    });
}

HttpClient de Java 11: GET asíncrono

El HttpClient de Java 11 proporciona HTTP completamente asíncrono mediante sendAsync(), que devuelve un CompletableFuture<HttpResponse<String>>.

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/users/1"))
    .build();
CompletableFuture<String> body = client
    .sendAsync(req, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body);

Encadenamiento de varias llamadas HTTP

Utilice thenCompose para encadenar llamadas HTTP dependientes: primero obtenga el usuario y, después, utilice su ID para obtener sus pedidos.

client.sendAsync(userReq, HttpResponse.BodyHandlers.ofString())
    .thenApply(r -> parseUser(r.body()))
    .thenCompose(user -> client.sendAsync(
        buildOrdersRequest(user.getId()),
        HttpResponse.BodyHandlers.ofString()))
    .thenApply(r -> parseOrders(r.body()))
    .thenAccept(orders -> System.out.println("Orders: " + orders.size()));

Llamadas HTTP en paralelo con allOf

Envíe solicitudes a varios endpoints en paralelo y recopile todas las respuestas cuando hayan finalizado.

List<URI> endpoints = List.of(uri1, uri2, uri3);
List<CompletableFuture<String>> requests = endpoints.stream()
    .map(uri -> client.sendAsync(
            HttpRequest.newBuilder(uri).build(),
            HttpResponse.BodyHandlers.ofString())
        .thenApply(HttpResponse::body))
    .collect(Collectors.toList());
List<String> responses = CompletableFuture
    .allOf(requests.toArray(new CompletableFuture[0]))
    .thenApply(v -> requests.stream().map(CompletableFuture::join).collect(Collectors.toList()))
    .join();

Tiempo de espera en llamadas HTTP

Aplique orTimeout directamente a la llamada HTTP asíncrona para cancelarla si el servidor tarda demasiado.

CompletableFuture<String> result = client
    .sendAsync(req, HttpResponse.BodyHandlers.ofString())
    .orTimeout(5, TimeUnit.SECONDS)
    .thenApply(HttpResponse::body)
    .exceptionally(ex -> "timeout or error");

Validación del código de estado en el flujo

Utilice thenApply para comprobar el código de estado HTTP y lanzar una excepción del dominio si indica un error, de modo que el manejo de errores del flujo sea coherente.

.thenApply(response -> {
    if (response.statusCode() != 200)
        throw new HttpResponseException(response.statusCode());
    return response.body();
})

Combinación de recuperación de errores y registro

Combine whenComplete para el registro y exceptionally para la recuperación en el mismo flujo: se integran correctamente.

fetchData()
    .whenComplete((r, ex) -> { if (ex != null) log.error("Failed", ex); })
    .exceptionally(ex -> fallback())
    .thenAccept(result -> process(result));

Comprobación rápida

¿Qué método de CompletableFuture se llama SOLO cuando falla el future?

Resumen

Utilice exceptionally para valores alternativos, handle para transformar ambos resultados y whenComplete para efectos secundarios. Cree flujos HTTP asíncronos con HttpClient de Java 11 + thenCompose + allOf.

Preguntas frecuentes

¿La lección «Gestión de errores y canalización HTTP asíncrona» es gratis?

Sí — el texto completo de «Gestión de errores y canalización HTTP asíncrona» 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 «Gestión de errores y canalización HTTP asíncrona»?

Gestione errores con exceptionally, handle y whenComplete, y después cree una canalización de cliente HTTP asíncrona. 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 4 de 4.

¿Cuánto tiempo toma la lección «Gestión de errores y canalización HTTP asíncrona»?

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

  1. Creación y finalización de CompletableFutures
  2. Encadenamiento con thenApply y thenCompose
  3. Combinación de futures: allOf y anyOf
  4. Gestión de errores y canalización HTTP asíncrona
← Volver a Java Academy