HttpClient cliente = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(5))
        .followRedirects(HttpClient.Redirect.NORMAL)
        .build();

HttpRequest peticion = HttpRequest.newBuilder()
        .uri(URI.create("http://localhost:8080/v1/libros/978-0000000001"))
        .header("Accept", "application/json")
        .timeout(Duration.ofSeconds(10))
        .GET()
        .build();

HttpResponse<String> respuesta = cliente.send(peticion,
        HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));

System.out.println(respuesta.statusCode());
System.out.println(respuesta.body());

import java.net.Authenticator;
import java.net.InetSocketAddress;
import java.net.PasswordAuthentication;
import java.net.ProxySelector;
import java.net.http.HttpClient;
import java.time.Duration;
import java.util.concurrent.Executors;

HttpClient cliente = HttpClient.newBuilder()

        // Version del protocolo. HTTP_2 es el valor por defecto y negocia:
        // si el servidor no lo soporta, cae a HTTP/1.1 sin que hagas nada.
        .version(HttpClient.Version.HTTP_2)

        // Tiempo limite para ESTABLECER la conexion. Es del cliente
        // porque afecta a todas sus peticiones.
        .connectTimeout(Duration.ofSeconds(5))

        // Politica de redirecciones.
        .followRedirects(HttpClient.Redirect.NORMAL)

        // Ejecutor para las operaciones asincronas. Si no se indica,
        // usa uno interno. Pasar el tuyo da control y nombres de hilo.
        .executor(Executors.newFixedThreadPool(8))

        // Proxy, si la red lo exige.
        .proxy(ProxySelector.of(new InetSocketAddress("proxy.nexussoftware.com", 3128)))

        // Autenticacion basica, para servicios que la usen.
        .authenticator(new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication("bibliotech",
                        "clave".toCharArray());
            }
        })

        .build();

HttpClient cliente = HttpClient.newHttpClient();

.header("Authorization", "Bearer " + token)

.executor(Executors.newFixedThreadPool(8, r -> {
    Thread h = new Thread(r, "bibliotech-http-" + contador.getAndIncrement());
    h.setDaemon(true);
    return h;
}))

// MAL. Un cliente nuevo por peticion.
for (String isbn : isbns) {
    HttpClient cliente = HttpClient.newHttpClient();      // <-- aqui esta el problema
    HttpResponse<String> r = cliente.send(peticionDe(isbn), ofString());
}

// BIEN. Uno, creado al arrancar, reutilizado siempre.
private static final HttpClient CLIENTE = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(5))
        .build();

for (String isbn : isbns) {
    HttpResponse<String> r = CLIENTE.send(peticionDe(isbn), ofString());
}

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

HttpRequest peticion = HttpRequest.newBuilder()

        // URI obligatoria. Fijate en que es URI, no URL: la API moderna
        // usa la clase correcta, sin el equals() que hace DNS (09-05).
        .uri(URI.create("https://api.nexussoftware.com/v1/libros/978-0000000001"))

        // Cabeceras. header() anade; setHeader() reemplaza si ya existe.
        .header("Accept", "application/json")
        .header("User-Agent", "BiblioTech/1.0")
        .header("Authorization", "Bearer " + token)

        // Varias de golpe: pares nombre, valor.
        .headers("Accept-Language", "es-ES", "X-Origen", "bibliotech")

        // TIEMPO LIMITE TOTAL de la peticion. Esto NO existia en
        // HttpURLConnection, que solo tenia limite por operacion.
        .timeout(Duration.ofSeconds(10))

        // Version especifica para esta peticion, si hace falta.
        .version(HttpClient.Version.HTTP_1_1)

        // El metodo. Uno de estos, al final.
        .GET()

        .build();

.GET()                                          // sin cuerpo
.DELETE()                                       // sin cuerpo
.POST(HttpRequest.BodyPublishers.ofString(json))
.PUT(HttpRequest.BodyPublishers.ofString(json))
.method("PATCH", HttpRequest.BodyPublishers.ofString(json))   // cualquier otro

// Plantilla con lo comun. Se construye una vez.
HttpRequest.Builder plantilla = HttpRequest.newBuilder()
        .header("Accept", "application/json")
        .header("User-Agent", "BiblioTech/1.0")
        .timeout(Duration.ofSeconds(10));

// Y por cada ISBN, solo cambia la URI.
// copy() clona el builder: sin el, modificariamos la plantilla.
HttpRequest p1 = plantilla.copy()
        .uri(URI.create(base + "/978-0000000001")).GET().build();
HttpRequest p2 = plantilla.copy()
        .uri(URI.create(base + "/978-0000000002")).GET().build();

import java.net.http.HttpRequest.BodyPublishers;

// JSON
HttpRequest p = HttpRequest.newBuilder()
        .uri(URI.create(base + "/v1/prestamos"))
        .header("Content-Type", "application/json; charset=utf-8")
        .POST(BodyPublishers.ofString(json, StandardCharsets.UTF_8))
        .build();

// Subir un fichero SIN cargarlo en memoria: se lee segun se envia.
// Con HttpURLConnection habia que hacer el streaming a mano.
HttpRequest subida = HttpRequest.newBuilder()
        .uri(URI.create(base + "/v1/catalogo/importar"))
        .header("Content-Type", "text/csv; charset=utf-8")
        .POST(BodyPublishers.ofFile(Path.of("catalogo.csv")))
        .build();

// Formulario: aqui URLEncoder SI es lo correcto (09-05).
String formulario = "isbn=" + URLEncoder.encode(isbn, UTF_8)
        + "&empleado=" + URLEncoder.encode(empleado, UTF_8);
HttpRequest form = HttpRequest.newBuilder()
        .uri(URI.create(base + "/v1/prestamos"))
        .header("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")
        .POST(BodyPublishers.ofString(formulario))
        .build();

import java.net.http.HttpResponse.BodyHandlers;

// Texto. El charset explicito, como siempre.
HttpResponse<String> texto = cliente.send(peticion,
        BodyHandlers.ofString(StandardCharsets.UTF_8));

// Directamente a un fichero. Adios al bucle de copia de 09-05.
HttpResponse<Path> fichero = cliente.send(peticion,
        BodyHandlers.ofFile(Path.of("portadas", isbn + ".jpg")));
System.out.println("Guardado en " + fichero.body());

// Como flujo, para procesar sin cargarlo entero.
HttpResponse<InputStream> flujo = cliente.send(peticion,
        BodyHandlers.ofInputStream());
try (InputStream entrada = flujo.body()) {
    // ... el InputStream del modulo 7, otra vez ...
}

// Solo interesa el codigo de estado (como un HEAD).
HttpResponse<Void> soloEstado = cliente.send(peticion, BodyHandlers.discarding());

HttpResponse<String> r = cliente.send(peticion, BodyHandlers.ofString(UTF_8));

int codigo = r.statusCode();              // 200
String cuerpo = r.body();                 // el cuerpo, del tipo T
HttpHeaders cabeceras = r.headers();      // las cabeceras
URI uri = r.uri();                        // la URI FINAL (tras redirecciones)
HttpClient.Version version = r.version(); // HTTP_2 o HTTP_1_1
HttpRequest original = r.request();       // la peticion que la produjo

// Las cabeceras, con una API decente:
Optional<String> tipo = r.headers().firstValue("Content-Type");
List<String> todas = r.headers().allValues("Set-Cookie");
OptionalLong longitud = r.headers().firstValueAsLong("Content-Length");

HttpResponse<String> respuesta = cliente.send(peticion,
        BodyHandlers.ofString(StandardCharsets.UTF_8));

try {
    HttpResponse<String> r = cliente.send(peticion, BodyHandlers.ofString(UTF_8));

    // OBLIGATORIO: comprobar el codigo. Un 500 NO lanza excepcion.
    if (r.statusCode() != 200) {
        throw new BiblioTechException("El servicio respondio " + r.statusCode()
                + ": " + recortar(r.body()));
    }
    procesar(r.body());

} catch (HttpTimeoutException e) {
    // Transitorio: merece reintento con espera creciente.
    throw new BiblioTechException("El servicio no responde a tiempo", e);

} catch (IOException e) {
    throw new BiblioTechException("Error de red consultando el servicio", e);

} catch (InterruptedException e) {
    Thread.currentThread().interrupt();     // 08-02: restaurar SIEMPRE la bandera
    throw new BiblioTechException("Consulta interrumpida", e);
}

CompletableFuture<HttpResponse<String>> futuro = cliente.sendAsync(peticion,
        BodyHandlers.ofString(StandardCharsets.UTF_8));

cliente.sendAsync(peticion, BodyHandlers.ofString(UTF_8))
        .thenApply(HttpResponse::body)              // extraer el cuerpo
        .thenApply(this::analizarMetadatos)         // convertirlo en objeto
        .thenAccept(m -> System.out.println(m.titulo()))
        .exceptionally(e -> {
            LOG.warning("Fallo: " + e.getMessage());
            return null;
        });
// El hilo actual sigue trabajando. No ha esperado a nada.

// MAL: escritura a disco en un hilo interno del HttpClient.
cliente.sendAsync(peticion, BodyHandlers.ofString(UTF_8))
        .thenApply(r -> { escribirEnDisco(r.body()); return r; });

// BIEN: el trabajo caro va a nuestro ejecutor.
cliente.sendAsync(peticion, BodyHandlers.ofString(UTF_8))
        .thenApplyAsync(r -> { escribirEnDisco(r.body()); return r; }, ejecutorEs);

CompletableFuture<Metadatos> futuro =
        cliente.sendAsync(peticionDe(isbn), BodyHandlers.ofString(UTF_8))
                .thenApply(r -> {
                    // El codigo se comprueba AQUI, dentro de la cadena.
                    if (r.statusCode() == 404) {
                        return null;
                    }
                    if (r.statusCode() != 200) {
                        // Lanzar dentro de la cadena la hace fallar,
                        // y el fallo llega al exceptionally.
                        throw new CompletionException(
                                new BiblioTechException("HTTP " + r.statusCode()));
                    }
                    return r.body();
                })
                .thenApply(this::analizarMetadatos);

// Primero los metadatos, y con la URL que traen, la portada.
CompletableFuture<Path> futuro =
        cliente.sendAsync(peticionMetadatos(isbn), BodyHandlers.ofString(UTF_8))
                .thenApply(r -> analizarMetadatos(r.body()))
                .thenCompose(m -> {
                    // Devuelve un CompletableFuture -> thenCompose, no thenApply.
                    // Con thenApply obtendriamos un
                    // CompletableFuture<CompletableFuture<HttpResponse<Path>>>.
                    HttpRequest p = HttpRequest.newBuilder()
                            .uri(URI.create(m.urlPortada()))
                            .timeout(Duration.ofSeconds(30))
                            .GET().build();
                    return cliente.sendAsync(p,
                            BodyHandlers.ofFile(Path.of("portadas", isbn + ".jpg")));
                })
                .thenApply(HttpResponse::body);

// Dos servicios distintos, consultados EN PARALELO.
CompletableFuture<String> metadatos =
        cliente.sendAsync(peticionMetadatos(isbn), BodyHandlers.ofString(UTF_8))
                .thenApply(HttpResponse::body);

CompletableFuture<String> valoraciones =
        cliente.sendAsync(peticionValoraciones(isbn), BodyHandlers.ofString(UTF_8))
                .thenApply(HttpResponse::body);

// El tiempo total es el del MAS LENTO, no la suma.
CompletableFuture<String> ficha = metadatos.thenCombine(valoraciones,
        (m, v) -> componerFicha(m, v));

cliente.sendAsync(peticion, BodyHandlers.ofString(UTF_8))
        .thenApply(this::procesar)
        .orTimeout(15, TimeUnit.SECONDS)        // plazo de TODA la cadena
        .exceptionally(e -> {
            if (e.getCause() instanceof TimeoutException) {
                LOG.warning("La cadena completa supero los 15 s");
            }
            return respuestaPorDefecto();
        });

package com.nexussoftware.bibliotech.red;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;

/** Consulta de varios ISBN en paralelo con allOf. */
public class ConsultaParalela {

    private final HttpClient cliente;
    private final String base;

    public ConsultaParalela(HttpClient cliente, String base) {
        this.cliente = cliente;
        this.base = base;
    }

    public List<String> consultarTodos(List<String> isbns) {
        List<CompletableFuture<String>> futuros = new ArrayList<>();

        // 1. Lanzar TODAS las peticiones. sendAsync devuelve al instante,
        //    asi que este bucle termina en microsegundos y las N peticiones
        //    quedan en vuelo simultaneamente.
        for (String isbn : isbns) {
            HttpRequest peticion = HttpRequest.newBuilder()
                    .uri(URI.create(base + "/v1/libros/" + isbn))
                    .header("Accept", "application/json")
                    .timeout(Duration.ofSeconds(10))
                    .GET()
                    .build();

            CompletableFuture<String> futuro =
                    cliente.sendAsync(peticion, BodyHandlers.ofString(StandardCharsets.UTF_8))
                            .thenApply(r -> r.statusCode() == 200
                                    ? r.body()
                                    : "ERROR " + r.statusCode() + " en " + isbn)
                            // BLINDAR CADA FUTURO ANTES DE AGREGARLO.
                            // Sin esto, un solo fallo hace fallar el allOf
                            // completo y perdemos las N-1 respuestas buenas.
                            // Es la trampa clasica de 08-07.
                            .exceptionally(e -> "FALLO en " + isbn + ": "
                                    + e.getCause().getMessage());

            futuros.add(futuro);
        }

        // 2. allOf se completa cuando TODOS terminan.
        CompletableFuture<Void> todos = CompletableFuture.allOf(
                futuros.toArray(new CompletableFuture[0]));

        // 3. Recoger. join() aqui es seguro porque allOf ya garantizo
        //    que todos estan completos: no bloquea nada.
        return todos.thenApply(v -> {
            List<String> resultados = new ArrayList<>(futuros.size());
            for (CompletableFuture<String> f : futuros) {
                resultados.add(f.join());
            }
            return resultados;
        }).join();      // el unico bloqueo real, y es intencionado
    }
}

// CODIGO ROTO. Muy comun.
HttpResponse<String> r = cliente.send(peticion, BodyHandlers.ofString(UTF_8));
Metadatos m = analizar(r.body());        // <-- si fue un 500, body() es
                                         //     la pagina de error del servidor

cliente.sendAsync(peticion, BodyHandlers.ofString(UTF_8))
        .thenApply(r -> {
            if (r.statusCode() == 404) {
                return null;        // "no existe" es un resultado, no un error
            }
            if (r.statusCode() / 100 == 5) {
                // Lanzar dentro de una etapa hace fallar el futuro,
                // y el fallo se propaga hasta el primer manejador.
                throw new CompletionException(
                        new BiblioTechException("Fallo del servidor: " + r.statusCode()));
            }
            if (r.statusCode() != 200) {
                throw new CompletionException(
                        new BiblioTechException("Respuesta inesperada: " + r.statusCode()));
            }
            return r.body();
        })
        .exceptionally(e -> {
            // OJO: la causa llega ENVUELTA en CompletionException (08-07).
            Throwable causa = e.getCause() != null ? e.getCause() : e;
            LOG.warning("Consulta fallida: " + causa.getMessage());
            return null;
        });

HTTP/1.1, seis peticiones en paralelo:
  conexion 1: [saludo][TLS][peticion A............]
  conexion 2: [saludo][TLS][peticion B............]
  ... seis conexiones, seis establecimientos ...

HTTP/2, seis peticiones en paralelo:
  conexion 1: [saludo][TLS][A|B|C|A|D|B|E|C|F|...]
  ... UNA conexion, UN establecimiento, flujos entrelazados ...

// Comprobar que version se negocio realmente.
HttpResponse<String> r = cliente.send(peticion, BodyHandlers.ofString(UTF_8));
System.out.println("Version negociada: " + r.version());   // HTTP_2 o HTTP_1_1

package com.nexussoftware.bibliotech.red;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.WebSocket;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.logging.Logger;

/**
 * Ejemplo minimo de WebSocket: BiblioTech recibiria avisos del servidor
 * en tiempo real ("el libro que esperabas esta disponible") sin sondear.
 */
public class AvisosWebSocket {

    private static final Logger LOG = Logger.getLogger(AvisosWebSocket.class.getName());

    public static void main(String[] args) throws Exception {
        HttpClient cliente = HttpClient.newHttpClient();

        // El Listener recibe los eventos. Fijate en request(1) al final
        // de cada metodo: WebSocket usa CONTRAPRESION, y hay que pedir
        // explicitamente el siguiente mensaje.
        WebSocket.Listener oyente = new WebSocket.Listener() {

            @Override
            public void onOpen(WebSocket ws) {
                LOG.info("Conexion WebSocket abierta");
                ws.request(1);      // pedimos el primer mensaje
            }

            @Override
            public CompletionStage<?> onText(WebSocket ws, CharSequence datos,
                                             boolean ultimo) {
                System.out.println("AVISO: " + datos);
                ws.request(1);      // y el siguiente
                return null;
            }

            @Override
            public CompletionStage<?> onClose(WebSocket ws, int codigo, String motivo) {
                LOG.info("WebSocket cerrado: " + codigo + " " + motivo);
                return null;
            }

            @Override
            public void onError(WebSocket ws, Throwable error) {
                LOG.warning("Error en WebSocket: " + error.getMessage());
            }
        };

        // buildAsync devuelve un CompletableFuture<WebSocket>: coherencia
        // total con el resto de la API.
        WebSocket ws = cliente.newWebSocketBuilder()
                .buildAsync(URI.create("ws://localhost:8080/avisos"), oyente)
                .join();

        ws.sendText("SUSCRIBIR 978-0000000001", true);

        Thread.sleep(30_000);       // escuchamos 30 segundos

        ws.sendClose(WebSocket.NORMAL_CLOSURE, "fin").join();
    }
}

// A MANO. Funciona para casos simples, y HAY QUE ESCAPAR.
String json = "{"
        + "\"isbn\":\"" + escapar(isbn) + "\","
        + "\"empleado\":\"" + escapar(empleado) + "\","
        + "\"dias\":" + dias
        + "}";

/**
 * Escape minimo de JSON. Los caracteres que ROMPEN el documento
 * si no se escapan son: la comilla doble, la barra invertida
 * y los caracteres de control.
 */
static String escapar(String texto) {
    StringBuilder sb = new StringBuilder(texto.length() + 16);
    for (int i = 0; i < texto.length(); i++) {
        char c = texto.charAt(i);
        switch (c) {
            case '"'  -> sb.append("\\\"");
            case '\\' -> sb.append("\\\\");
            case '\n' -> sb.append("\\n");
            case '\r' -> sb.append("\\r");
            case '\t' -> sb.append("\\t");
            default -> {
                if (c < 0x20) {
                    sb.append(String.format("\\u%04x", (int) c));
                } else {
                    sb.append(c);
                }
            }
        }
    }
    return sb.toString();
}

/**
 * Extrae "campo":"valor" de un JSON POR BUSQUEDA DE SUBCADENA.
 *
 * ESTO ES UN APAÑO DIDACTICO Y HAY QUE DECIRLO CLARO.
 *
 * Funciona con respuestas planas y sencillas como las de este servicio,
 * y SE ROMPE con:
 *   - valores que contengan la subcadena buscada
 *   - comillas escapadas dentro de un valor ("Java \"Efectivo\"")
 *   - objetos anidados o arrays
 *   - un campo del mismo nombre en un objeto interno
 *   - valores null, numericos o booleanos donde se espera texto
 *   - espacios distintos alrededor de los dos puntos
 *
 * HACERLO BIEN REQUIERE UNA LIBRERIA DE JSON, Y ESO ES 11-07 (JACKSON),
 * donde una linea -mapper.readValue(json, Metadatos.class)- sustituye
 * a todo esto y encima convierte directamente al record. No lleves
 * este codigo a produccion.
 */
static String campoTexto(String json, String campo) {
    String marca = "\"" + campo + "\"";
    int i = json.indexOf(marca);
    if (i < 0) {
        return null;
    }
    int dosPuntos = json.indexOf(':', i + marca.length());
    if (dosPuntos < 0) {
        return null;
    }
    int abre = json.indexOf('"', dosPuntos);
    if (abre < 0) {
        return null;
    }
    // Buscamos la comilla de cierre saltando las escapadas.
    int j = abre + 1;
    StringBuilder valor = new StringBuilder();
    while (j < json.length()) {
        char c = json.charAt(j);
        if (c == '\\' && j + 1 < json.length()) {
            valor.append(json.charAt(j + 1));
            j += 2;
            continue;
        }
        if (c == '"') {
            return valor.toString();
        }
        valor.append(c);
        j++;
    }
    return null;
}

HttpClient cliente = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(5))      // establecer
        .build();

HttpRequest peticion = HttpRequest.newBuilder()
        .timeout(Duration.ofSeconds(10))            // total de la peticion
        .build();

// El cliente genera un identificador UNICO por operacion logica
// -no por intento- y lo envia. El servidor almacena las claves ya
// vistas y devuelve el resultado anterior en vez de repetir la
// operacion. Con esto, reintentar SI es seguro.
String clave = UUID.randomUUID().toString();

HttpRequest peticion = HttpRequest.newBuilder()
        .uri(URI.create(base + "/v1/prestamos"))
        .header("Idempotency-Key", clave)       // la MISMA en todos los reintentos
        .header("Content-Type", "application/json")
        .POST(BodyPublishers.ofString(json))
        .build();

// MAL: el token acaba en el fichero de log, y de ahi en la copia de
// seguridad, en el sistema de agregacion de logs y en cualquier
// captura de pantalla de soporte.
LOG.info("Peticion: " + peticion.headers());

// BIEN: solo lo que se puede registrar.
LOG.info(() -> "GET " + peticion.uri().getPath()
        + " -> " + respuesta.statusCode()
        + " (" + ms + " ms)");

.header("User-Agent", "BiblioTech/1.0 (+https://nexussoftware.com/bibliotech)")

HttpClient cliente = HttpClient.newBuilder()
        .sslContext(contextoConAlmacenPropio())      // NO un TrustManager que acepte todo
        .build();

package com.nexussoftware.bibliotech.red;

import com.nexussoftware.bibliotech.dominio.Material;
import com.nexussoftware.bibliotech.servicio.CatalogoConcurrente;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Enriquece el catalogo de BiblioTech con datos del servicio externo
 * de metadatos, consultando TODOS los ISBN en paralelo y descargando
 * las portadas sin bloquear un solo hilo.
 *
 * Resuelve el problema que dejo abierto SincronizadorPortadas (09-05),
 * que era secuencial y pasaba todo el tiempo esperando a la red.
 *
 * Aplica: HttpClient reutilizado, sendAsync + thenCompose + allOf de 08-07,
 * Semaphore de 08-05 para acotar el paralelismo, y LongAdder de 08-06
 * para las metricas.
 */
public class EnriquecedorCatalogo implements AutoCloseable {

    private static final Logger LOG =
            Logger.getLogger(EnriquecedorCatalogo.class.getName());

    private static final String AGENTE = "BiblioTech/1.0 (+https://nexussoftware.com)";
    private static final int MAXIMO_SIMULTANEAS = 8;
    private static final long MAXIMO_PORTADA = 5L * 1024 * 1024;

    private final String base;
    private final Path directorioPortadas;
    private final HttpClient cliente;
    private final ExecutorService ejecutor;

    /**
     * Acota el paralelismo. Sin el, mil ISBN generarian mil peticiones
     * simultaneas y el servicio nos devolveria 429 o nos bloquearia la IP.
     * Es el Semaphore de 08-05, aplicado a la red.
     */
    private final Semaphore permisos = new Semaphore(MAXIMO_SIMULTANEAS);

    // Metricas sin contencion (08-06).
    private final LongAdder enriquecidos = new LongAdder();
    private final LongAdder noEncontrados = new LongAdder();
    private final LongAdder portadasDescargadas = new LongAdder();
    private final LongAdder fallidos = new LongAdder();
    private final LongAdder bytesPortadas = new LongAdder();

    public EnriquecedorCatalogo(String base, Path directorioPortadas) {
        this.base = base.endsWith("/") ? base.substring(0, base.length() - 1) : base;
        this.directorioPortadas = directorioPortadas;

        // Ejecutor propio con hilos NOMBRADOS (08-02): en un volcado de
        // hilos y en cada linea de log sabras quien hace que.
        AtomicInteger n = new AtomicInteger(1);
        this.ejecutor = Executors.newFixedThreadPool(MAXIMO_SIMULTANEAS, r -> {
            Thread h = new Thread(r, "bibliotech-http-" + n.getAndIncrement());
            h.setDaemon(true);
            return h;
        });

        // UN cliente, creado una vez y reutilizado: pool de conexiones,
        // sesiones TLS reutilizadas y multiplexacion HTTP/2.
        this.cliente = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)
                .connectTimeout(Duration.ofSeconds(5))
                .followRedirects(HttpClient.Redirect.NORMAL)
                .executor(ejecutor)
                .build();
    }

    /** Ficha enriquecida de un material. */
    public record FichaEnriquecida(String isbn, String titulo, String autor,
                                   int paginas, Path portada, String estado) {
    }

    // =================================================================
    // Punto de entrada
    // =================================================================

    public List<FichaEnriquecida> enriquecer(CatalogoConcurrente catalogo) {
        List<Material> materiales = catalogo.todos();
        List<String> isbns = new ArrayList<>(materiales.size());
        for (Material m : materiales) {
            isbns.add(m.getIsbn());
        }
        return enriquecerIsbns(isbns);
    }

    public List<FichaEnriquecida> enriquecerIsbns(List<String> isbns) {
        long inicio = System.currentTimeMillis();
        System.out.println("Enriqueciendo " + isbns.size()
                + " materiales (hasta " + MAXIMO_SIMULTANEAS + " a la vez)...\n");

        try {
            Files.createDirectories(directorioPortadas);
        } catch (Exception e) {
            LOG.log(Level.WARNING, "No se pudo crear el directorio de portadas", e);
        }

        // --- 1. Lanzar TODAS las cadenas ---
        // sendAsync devuelve al instante, asi que este bucle termina en
        // microsegundos con N cadenas en marcha.
        List<CompletableFuture<FichaEnriquecida>> futuros =
                new ArrayList<>(isbns.size());
        for (String isbn : isbns) {
            futuros.add(cadenaDe(isbn));
        }

        // --- 2. Esperar a todas ---
        CompletableFuture<Void> todas = CompletableFuture.allOf(
                futuros.toArray(new CompletableFuture[0]));

        // --- 3. Recoger ---
        List<FichaEnriquecida> fichas = todas.thenApply(v -> {
            List<FichaEnriquecida> lista = new ArrayList<>(futuros.size());
            for (CompletableFuture<FichaEnriquecida> f : futuros) {
                // join() seguro: allOf ya garantizo que todos estan completos.
                lista.add(f.join());
            }
            return lista;
        }).join();      // el unico bloqueo real, intencionado

        informe(System.currentTimeMillis() - inicio, isbns.size());
        return fichas;
    }

    // =================================================================
    // La cadena asincrona de UN material
    // =================================================================

    private CompletableFuture<FichaEnriquecida> cadenaDe(String isbn) {
        if (!isbnValido(isbn)) {
            fallidos.increment();
            return CompletableFuture.completedFuture(
                    new FichaEnriquecida(isbn, null, null, 0, null, "ISBN INVALIDO"));
        }

        HttpRequest peticion = HttpRequest.newBuilder()
                .uri(URI.create(base + "/v1/libros/" + isbn))
                .header("Accept", "application/json")
                .header("User-Agent", AGENTE)
                .timeout(Duration.ofSeconds(10))    // limite TOTAL, no por operacion
                .GET()
                .build();

        // adquirirPermiso bloquea si ya hay 8 en vuelo. Se hace ANTES
        // del sendAsync para que el semaforo limite peticiones reales.
        adquirirPermiso();

        return cliente.sendAsync(peticion, BodyHandlers.ofString(StandardCharsets.UTF_8))

                // --- Etapa 1: comprobar el codigo y quedarnos con el cuerpo ---
                .thenApply(respuesta -> {
                    liberarPermiso();

                    int codigo = respuesta.statusCode();
                    LOG.fine(() -> "GET /v1/libros/" + isbn + " -> " + codigo);

                    if (codigo == 404) {
                        return null;        // "no lo tengo" es un resultado
                    }
                    if (codigo != 200) {
                        // Lanzar aqui hace fallar el futuro; el fallo llega
                        // al exceptionally del final.
                        throw new CompletionException(
                                new java.io.IOException("HTTP " + codigo
                                        + " consultando " + isbn));
                    }
                    return respuesta.body();
                })

                // --- Etapa 2: analizar el JSON ---
                .thenApply(cuerpo -> {
                    if (cuerpo == null) {
                        noEncontrados.increment();
                        return new FichaEnriquecida(isbn, null, null, 0, null,
                                "NO ENCONTRADO");
                    }
                    String titulo = campoTexto(cuerpo, "titulo");
                    String autor = campoTexto(cuerpo, "autor");
                    String portada = campoTexto(cuerpo, "portada");
                    int paginas = campoEntero(cuerpo, "paginas");

                    if (titulo == null) {
                        throw new CompletionException(
                                new java.io.IOException("Respuesta sin titulo"));
                    }
                    enriquecidos.increment();
                    return new FichaEnriquecida(isbn, titulo,
                            autor == null ? "(desconocido)" : autor,
                            paginas,
                            portada == null ? null : Path.of(portada),  // marcador
                            "OK");
                })

                // --- Etapa 3: descargar la portada, si la hay ---
                // thenCompose porque devuelve OTRO CompletableFuture:
                // con thenApply tendriamos un futuro de un futuro (08-07).
                .thenCompose(ficha -> {
                    if (ficha.portada() == null) {
                        return CompletableFuture.completedFuture(ficha);
                    }
                    // El campo 'portada' lleva la URL de forma provisional.
                    String url = ficha.portada().toString();
                    return descargarPortada(url, isbn)
                            .thenApply(ruta -> new FichaEnriquecida(
                                    ficha.isbn(), ficha.titulo(), ficha.autor(),
                                    ficha.paginas(), ruta,
                                    ruta == null ? "OK (sin portada)" : "OK"));
                })

                // --- Plazo de la cadena COMPLETA ---
                .orTimeout(30, TimeUnit.SECONDS)

                // --- Blindaje: OBLIGATORIO antes de agregar al allOf ---
                // Sin esto, un solo fallo hace fallar el allOf entero y
                // perdemos todas las fichas buenas. Trampa clasica de 08-07.
                .exceptionally(e -> {
                    liberarPermiso();       // por si fallo antes de liberarlo
                    fallidos.increment();
                    // La causa llega ENVUELTA en CompletionException.
                    Throwable causa = e.getCause() != null ? e.getCause() : e;
                    LOG.warning("Fallo enriqueciendo " + isbn + ": "
                            + causa.getMessage());
                    return new FichaEnriquecida(isbn, null, null, 0, null,
                            "FALLO: " + causa.getClass().getSimpleName());
                });
    }

    /** Descarga la portada a disco. Devuelve null si no se pudo. */
    private CompletableFuture<Path> descargarPortada(String url, String isbn) {
        if (!url.startsWith("http://") && !url.startsWith("https://")) {
            // Sin esta comprobacion, una URL "file:///etc/passwd" recibida
            // del servicio nos haria leer ficheros locales.
            LOG.warning("Esquema no permitido en la portada de " + isbn);
            return CompletableFuture.completedFuture(null);
        }

        Path destino = directorioPortadas.resolve(isbn + ".jpg");

        HttpRequest peticion = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Accept", "image/jpeg, image/png, image/*")
                .header("User-Agent", AGENTE)
                .timeout(Duration.ofSeconds(30))
                .GET()
                .build();

        adquirirPermiso();

        // BodyHandlers.ofFile escribe directamente a disco, sin cargar
        // la imagen en memoria y sin el bucle de copia de 09-05.
        return cliente.sendAsync(peticion, BodyHandlers.ofFile(destino))
                .thenApply(respuesta -> {
                    liberarPermiso();
                    if (respuesta.statusCode() != 200) {
                        LOG.fine("Portada de " + isbn + ": HTTP "
                                + respuesta.statusCode());
                        return null;
                    }
                    Path ruta = respuesta.body();
                    try {
                        long tamano = Files.size(ruta);
                        if (tamano > MAXIMO_PORTADA) {
                            Files.deleteIfExists(ruta);
                            LOG.warning("Portada de " + isbn + " demasiado grande");
                            return null;
                        }
                        bytesPortadas.add(tamano);
                    } catch (Exception e) {
                        LOG.fine("No se pudo comprobar el tamano: " + e.getMessage());
                    }
                    portadasDescargadas.increment();
                    return ruta;
                })
                .exceptionally(e -> {
                    liberarPermiso();
                    LOG.fine("Fallo descargando la portada de " + isbn);
                    return null;    // sin portada no es un fallo del enriquecido
                });
    }

    // =================================================================
    // Semaforo
    // =================================================================

    private void adquirirPermiso() {
        try {
            permisos.acquire();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();      // 08-02
            throw new CompletionException(e);
        }
    }

    private void liberarPermiso() {
        permisos.release();
    }

    // =================================================================
    // Analisis de JSON: APAÑO DIDACTICO, ver el apartado 15
    // =================================================================

    /**
     * Extraccion por busqueda de subcadena. Funciona con las respuestas
     * planas de este servicio y se rompe con anidamiento, arrays o campos
     * repetidos. HACERLO BIEN ES JACKSON, Y ESO ES 11-07.
     */
    private String campoTexto(String json, String campo) {
        String marca = "\"" + campo + "\"";
        int i = json.indexOf(marca);
        if (i < 0) {
            return null;
        }
        int dosPuntos = json.indexOf(':', i + marca.length());
        if (dosPuntos < 0) {
            return null;
        }
        int abre = json.indexOf('"', dosPuntos);
        if (abre < 0) {
            return null;
        }
        StringBuilder valor = new StringBuilder();
        int j = abre + 1;
        while (j < json.length()) {
            char c = json.charAt(j);
            if (c == '\\' && j + 1 < json.length()) {
                valor.append(json.charAt(j + 1));
                j += 2;
                continue;
            }
            if (c == '"') {
                return valor.toString();
            }
            valor.append(c);
            j++;
        }
        return null;
    }

    private int campoEntero(String json, String campo) {
        String marca = "\"" + campo + "\"";
        int i = json.indexOf(marca);
        if (i < 0) {
            return 0;
        }
        int j = json.indexOf(':', i + marca.length()) + 1;
        while (j < json.length() && !Character.isDigit(json.charAt(j))) {
            if (json.charAt(j) == ',' || json.charAt(j) == '}') {
                return 0;
            }
            j++;
        }
        int inicio = j;
        while (j < json.length() && Character.isDigit(json.charAt(j))) {
            j++;
        }
        return inicio == j ? 0 : Integer.parseInt(json.substring(inicio, j));
    }

    private boolean isbnValido(String isbn) {
        if (isbn == null || isbn.isBlank() || isbn.length() > 20) {
            return false;
        }
        // Lista blanca: impide inyectar rutas ("../admin") en la URL.
        for (int i = 0; i < isbn.length(); i++) {
            char c = isbn.charAt(i);
            if (!Character.isDigit(c) && c != '-') {
                return false;
            }
        }
        return true;
    }

    // =================================================================
    // Informe y cierre
    // =================================================================

    private void informe(long ms, int total) {
        System.out.println();
        System.out.println("=== ENRIQUECIMIENTO DE CATALOGO ===");
        System.out.printf("%-26s %d%n", "Materiales", total);
        System.out.printf("%-26s %d%n", "Enriquecidos", enriquecidos.sum());
        System.out.printf("%-26s %d%n", "No encontrados", noEncontrados.sum());
        System.out.printf("%-26s %d%n", "Fallidos", fallidos.sum());
        System.out.printf("%-26s %d%n", "Portadas descargadas",
                portadasDescargadas.sum());
        System.out.printf("%-26s %.1f KB%n", "Bytes de portadas",
                bytesPortadas.sum() / 1024.0);
        System.out.printf("%-26s %.2f s%n", "Tiempo total", ms / 1000.0);
        if (total > 0) {
            System.out.printf("%-26s %.1f ms%n", "Media por material",
                    (double) ms / total);
        }
    }

    @Override
    public void close() {
        // Apagado en dos fases (08-05).
        ejecutor.shutdown();
        try {
            if (!ejecutor.awaitTermination(10, TimeUnit.SECONDS)) {
                LOG.warning("Peticiones aun activas; se fuerza el cierre");
                ejecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            ejecutor.shutdownNow();
            Thread.currentThread().interrupt();      // 08-02
        }
        LOG.info("EnriquecedorCatalogo cerrado");
    }
}

package com.nexussoftware.bibliotech.presentacion;

import com.nexussoftware.bibliotech.red.EnriquecedorCatalogo;
import com.nexussoftware.bibliotech.red.EnriquecedorCatalogo.FichaEnriquecida;

import java.nio.file.Path;
import java.util.List;

public class PruebaEnriquecedor {

    public static void main(String[] args) {
        List<String> isbns = List.of(
                "978-0000000001", "978-0000000002", "978-0000000003",
                "978-0000000004", "978-0000000005", "978-0000000006",
                "978-0000000007", "978-0000000008", "978-0000000009",
                "978-0000000010", "978-0000000011", "978-0000000012",
                "978-0000000013", "978-0000000014", "978-0000000015",
                "978-0000000016", "978-0000000017", "978-0000000018",
                "978-0000000019", "978-0000000020");

        // AutoCloseable: apagado ordenado del ejecutor.
        try (EnriquecedorCatalogo enriquecedor = new EnriquecedorCatalogo(
                "http://localhost:8080", Path.of("portadas"))) {

            List<FichaEnriquecida> fichas = enriquecedor.enriquecerIsbns(isbns);

            System.out.println("\n--- RESULTADO ---");
            for (FichaEnriquecida f : fichas) {
                System.out.printf("  %-18s %-30s %s%n",
                        f.isbn(),
                        f.titulo() == null ? "-" : f.titulo(),
                        f.estado());
            }
        }
    }
}

Enriqueciendo 20 materiales (hasta 8 a la vez)...

=== ENRIQUECIMIENTO DE CATALOGO ===
Materiales                 20
Enriquecidos               17
No encontrados             2
Fallidos                   1
Portadas descargadas       15
Bytes de portadas          682.4 KB
Tiempo total               1.24 s
Media por material         62.0 ms

--- RESULTADO ---
  978-0000000001     Java Efectivo                  OK
  978-0000000002     Patrones de Diseno             OK
  978-0000000003     Refactorizacion                OK
  978-0000000004     -                              NO ENCONTRADO
  ...
  978-0000000019     -                              FALLO: HttpTimeoutException

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.net.ConnectException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.net.http.HttpTimeoutException;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Logger;

/**
 * Cliente HTTP asincrono con reintentos, sobre java.net.http.
 *
 * La clave del ejercicio: los reintentos se hacen DENTRO de la cadena
 * asincrona con thenCompose recursivo y delayedExecutor. Ningun hilo
 * se bloquea esperando entre intentos.
 */
public class ClienteAsincronoResistente implements AutoCloseable {

    private static final Logger LOG =
            Logger.getLogger(ClienteAsincronoResistente.class.getName());

    private static final int MAXIMO_INTENTOS = 4;
    private static final long ESPERA_INICIAL_MS = 200;
    private static final long MAXIMO_RETRY_AFTER_MS = 30_000;

    private final HttpClient cliente;
    private final ExecutorService ejecutor;

    public ClienteAsincronoResistente() {
        AtomicInteger n = new AtomicInteger(1);
        this.ejecutor = Executors.newFixedThreadPool(8, r -> {
            Thread h = new Thread(r, "http-resistente-" + n.getAndIncrement());
            h.setDaemon(true);
            return h;
        });
        // UN cliente, reutilizado: pool de conexiones y sesiones TLS.
        this.cliente = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(5))
                .followRedirects(HttpClient.Redirect.NORMAL)
                .executor(ejecutor)
                .build();
    }

    public record Respuesta(int codigo, String cuerpo,
                            Map<String, List<String>> cabeceras, int intentos) {

        public boolean exito() {
            return codigo >= 200 && codigo < 300;
        }
    }

    // =================================================================
    // API publica
    // =================================================================

    public CompletableFuture<Respuesta> get(String url) {
        HttpRequest peticion = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Accept", "application/json, */*")
                .header("User-Agent", "BiblioTech/1.0")
                .timeout(Duration.ofSeconds(10))
                .GET()
                .build();
        return conReintentos(peticion, 1, ESPERA_INICIAL_MS);
    }

    /**
     * POST SIN reintentos. Si agota el plazo, no sabemos si el servidor
     * lo proceso; reintentar podria duplicar la operacion.
     */
    public CompletableFuture<Respuesta> post(String url, String cuerpo, String tipo) {
        return conReintentos(construirPost(url, cuerpo, tipo, null),
                MAXIMO_INTENTOS, 0);    // empezar en el ultimo intento = sin reintentos
    }

    /**
     * POST CON reintentos, usando clave de idempotencia.
     *
     * La clave se genera UNA VEZ, fuera de la cadena, y viaja igual en
     * todos los reintentos. Eso es lo que permite al servidor reconocer
     * que es la misma operacion logica y no repetirla.
     */
    public CompletableFuture<Respuesta> postIdempotente(String url, String cuerpo,
                                                        String tipo) {
        String clave = UUID.randomUUID().toString();
        return conReintentos(construirPost(url, cuerpo, tipo, clave),
                1, ESPERA_INICIAL_MS);
    }

    private HttpRequest construirPost(String url, String cuerpo, String tipo,
                                      String claveIdempotencia) {
        HttpRequest.Builder b = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Content-Type", tipo == null
                        ? "application/json; charset=utf-8" : tipo)
                .header("Accept", "application/json")
                .header("User-Agent", "BiblioTech/1.0")
                .timeout(Duration.ofSeconds(15))
                .POST(HttpRequest.BodyPublishers.ofString(cuerpo, StandardCharsets.UTF_8));

        if (claveIdempotencia != null) {
            b = b.header("Idempotency-Key", claveIdempotencia);
        }
        return b.build();
    }

    // =================================================================
    // Nucleo: reintentos DENTRO de la cadena asincrona
    // =================================================================

    private CompletableFuture<Respuesta> conReintentos(HttpRequest peticion,
                                                       int intento, long espera) {

        return cliente.sendAsync(peticion, BodyHandlers.ofString(StandardCharsets.UTF_8))

                // --- Caso 1: hubo respuesta. Puede ser un codigo transitorio. ---
                .thenCompose(respuesta -> {
                    int codigo = respuesta.statusCode();

                    if (esTransitorio(codigo) && intento < MAXIMO_INTENTOS) {
                        long esperaReal = esperaTras(respuesta, espera);
                        LOG.warning(peticion.method() + " " + peticion.uri().getPath()
                                + " -> " + codigo + "; reintento " + (intento + 1)
                                + " en " + esperaReal + " ms");

                        // AQUI ESTA LA CLAVE DEL EJERCICIO.
                        // delayedExecutor devuelve un Executor que ejecuta
                        // la tarea TRAS el retardo, sin bloquear ningun hilo.
                        // Un Thread.sleep aqui dejaria parado un hilo del pool
                        // durante toda la espera, que es justo lo que queremos evitar.
                        Executor retardado = CompletableFuture.delayedExecutor(
                                esperaReal, TimeUnit.MILLISECONDS, ejecutor);

                        // supplyAsync sobre el ejecutor retardado + thenCompose:
                        // la recursion se convierte en otra etapa de la cadena.
                        return CompletableFuture
                                .supplyAsync(() -> null, retardado)
                                .thenCompose(v -> conReintentos(peticion,
                                        intento + 1, espera * 2));
                    }

                    return CompletableFuture.completedFuture(new Respuesta(
                            codigo, respuesta.body(), respuesta.headers().map(), intento));
                })

                // --- Caso 2: hubo excepcion. Puede ser transitoria. ---
                .handle((resultado, error) -> {
                    if (error == null) {
                        return CompletableFuture.completedFuture(resultado);
                    }
                    // La causa llega ENVUELTA en CompletionException (08-07).
                    Throwable causa = error.getCause() != null ? error.getCause() : error;

                    if (esTransitoria(causa) && intento < MAXIMO_INTENTOS) {
                        long esperaReal = conJitter(espera);
                        LOG.warning(causa.getClass().getSimpleName() + " en "
                                + peticion.uri().getPath() + "; reintento "
                                + (intento + 1) + " en " + esperaReal + " ms");

                        Executor retardado = CompletableFuture.delayedExecutor(
                                esperaReal, TimeUnit.MILLISECONDS, ejecutor);
                        return CompletableFuture
                                .supplyAsync(() -> null, retardado)
                                .thenCompose(v -> conReintentos(peticion,
                                        intento + 1, espera * 2));
                    }

                    // Permanente o sin intentos: se propaga el fallo.
                    return CompletableFuture.<Respuesta>failedFuture(causa);
                })
                // handle devuelve CompletableFuture<CompletableFuture<Respuesta>>:
                // thenCompose lo aplana. Es el map/flatMap de 08-07.
                .thenCompose(f -> f);
    }

    // =================================================================
    // Politica
    // =================================================================

    private boolean esTransitorio(int codigo) {
        // El 500 se excluye a proposito: suele ser un fallo determinista
        // del servidor que se repetira identicamente.
        return codigo == 429 || codigo == 502 || codigo == 503 || codigo == 504;
    }

    private boolean esTransitoria(Throwable t) {
        // HttpTimeoutException es subclase de IOException, y ConnectException
        // tambien: hay que comprobar las concretas ANTES que IOException.
        return t instanceof HttpTimeoutException
                || t instanceof ConnectException
                || (t instanceof IOException && !(t.getMessage() != null
                        && t.getMessage().contains("UnresolvedAddress")));
    }

    private long esperaTras(HttpResponse<?> respuesta, long calculada) {
        // firstValue devuelve Optional porque la cabecera puede no estar.
        // Aqui lo usamos con isPresent()/get(); el estilo fluido de Optional
        // (map, orElseGet, ifPresent) se ve en 10-04.
        java.util.Optional<String> retryAfter =
                respuesta.headers().firstValue("Retry-After");

        if (retryAfter.isPresent()) {
            try {
                // Solo el formato en segundos; el de fecha exige analizar
                // fechas HTTP, y eso se hace bien en 10-05.
                long ms = Long.parseLong(retryAfter.get().strip()) * 1000;
                return Math.min(ms, MAXIMO_RETRY_AFTER_MS);
            } catch (NumberFormatException e) {
                LOG.fine("Retry-After en formato de fecha; se ignora");
            }
        }
        return conJitter(calculada);
    }

    /**
     * Aleatoriza la espera un 20 %.
     * Evita el "rebano atronador": si cien clientes fallan a la vez y todos
     * reintentan exactamente a los 200 ms, la rafaga sincronizada vuelve a
     * tumbar el servicio que se estaba recuperando, en un ciclo indefinido.
     */
    private long conJitter(long base) {
        if (base <= 0) {
            return 0;
        }
        long variacion = Math.max(1, base / 5);
        return base + ThreadLocalRandom.current().nextLong(-variacion, variacion + 1);
    }

    @Override
    public void close() {
        ejecutor.shutdown();        // apagado en dos fases (08-05)
        try {
            if (!ejecutor.awaitTermination(10, TimeUnit.SECONDS)) {
                ejecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            ejecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

    // =================================================================
    // Prueba
    // =================================================================

    public static void main(String[] args) {
        String base = args.length > 0 ? args[0] : "http://localhost:8080";

        try (ClienteAsincronoResistente c = new ClienteAsincronoResistente()) {

            List<CompletableFuture<Respuesta>> futuros = new java.util.ArrayList<>();
            long t0 = System.currentTimeMillis();

            for (int i = 1; i <= 10; i++) {
                futuros.add(c.get(base + "/v1/libros/978-000000000" + (i % 10))
                        // Blindaje individual ANTES del allOf: sin el, un
                        // fallo tumbaria las diez.
                        .exceptionally(e -> new Respuesta(-1,
                                "FALLO: " + e.getCause().getMessage(),
                                Map.of(), MAXIMO_INTENTOS)));
            }

            CompletableFuture.allOf(futuros.toArray(new CompletableFuture[0])).join();
            long ms = System.currentTimeMillis() - t0;

            int ok = 0, fallidas = 0, reintentadas = 0;
            for (CompletableFuture<Respuesta> f : futuros) {
                Respuesta r = f.join();     // seguro: allOf ya termino
                if (r.exito()) {
                    ok++;
                } else {
                    fallidas++;
                }
                if (r.intentos() > 1) {
                    reintentadas++;
                }
                System.out.printf("  codigo=%-5d intentos=%d%n", r.codigo(), r.intentos());
            }

            System.out.println();
            System.out.printf("Correctas: %d   Fallidas: %d   Con reintento: %d%n",
                    ok, fallidas, reintentadas);
            System.out.printf("Tiempo total: %d ms%n", ms);
        }
    }
}

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;

/**
 * Compara cuatro estrategias para hacer N peticiones HTTP.
 * Demuestra con numeros por que la asincrona acotada es la respuesta.
 */
public class ComparadorEstrategias {

    private final String base;
    private final int peticiones;
    private final HttpClient cliente;

    public ComparadorEstrategias(String base, int peticiones) {
        this.base = base;
        this.peticiones = peticiones;
        // UN cliente para todas las estrategias: asi la comparacion es
        // justa y no medimos el coste de crear clientes.
        this.cliente = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(5))
                .build();
    }

    public record Resultado(String estrategia, long ms, int correctas, int fallidas,
                            double mediaLatenciaMs, int hilosMaximos) {
    }

    private HttpRequest peticionDe(int i) {
        return HttpRequest.newBuilder()
                .uri(URI.create(base + "/v1/libros/978-" + String.format("%010d", i)))
                .header("Accept", "application/json")
                .timeout(Duration.ofSeconds(15))
                .GET()
                .build();
    }

    // =================================================================
    // Vigilante de hilos
    // =================================================================

    /** Muestrea Thread.activeCount() en un hilo aparte durante la medida. */
    private static class VigilanteHilos {
        private final AtomicInteger maximo = new AtomicInteger();
        private volatile boolean activo = true;
        private Thread hilo;

        void arrancar() {
            hilo = new Thread(() -> {
                while (activo) {
                    maximo.updateAndGet(m -> Math.max(m, Thread.activeCount()));
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }
            }, "vigilante-hilos");
            hilo.setDaemon(true);
            hilo.start();
        }

        int parar() {
            activo = false;
            try {
                hilo.join(500);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return maximo.get();
        }
    }

    // =================================================================
    // A: secuencial
    // =================================================================

    public Resultado secuencial() {
        VigilanteHilos vigilante = new VigilanteHilos();
        vigilante.arrancar();

        int correctas = 0, fallidas = 0;
        long sumaLatencias = 0;
        long t0 = System.currentTimeMillis();

        for (int i = 0; i < peticiones; i++) {
            long p0 = System.nanoTime();
            try {
                HttpResponse<Void> r = cliente.send(peticionDe(i),
                        BodyHandlers.discarding());
                if (r.statusCode() == 200) {
                    correctas++;
                } else {
                    fallidas++;
                }
            } catch (IOException e) {
                fallidas++;
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();      // 08-02
                break;
            }
            sumaLatencias += (System.nanoTime() - p0) / 1_000_000;
        }

        long ms = System.currentTimeMillis() - t0;
        return new Resultado("A. Secuencial (send en bucle)", ms, correctas, fallidas,
                peticiones == 0 ? 0 : (double) sumaLatencias / peticiones,
                vigilante.parar());
    }

    // =================================================================
    // B: pool de hilos con send bloqueante
    // =================================================================

    public Resultado poolBloqueante() throws InterruptedException {
        VigilanteHilos vigilante = new VigilanteHilos();
        vigilante.arrancar();

        AtomicInteger correctas = new AtomicInteger();
        AtomicInteger fallidas = new AtomicInteger();
        LongAdder sumaLatencias = new LongAdder();

        ExecutorService pool = Executors.newFixedThreadPool(8);
        CountDownLatch salida = new CountDownLatch(1);
        CountDownLatch llegada = new CountDownLatch(peticiones);

        for (int i = 0; i < peticiones; i++) {
            final int n = i;
            pool.execute(() -> {
                try {
                    salida.await();     // todos arrancan a la vez
                    long p0 = System.nanoTime();
                    // send BLOQUEA el hilo del pool durante toda la espera
                    // de red. Ocho hilos = ocho peticiones simultaneas,
                    // y siete de cada ocho hilos estan parados sin hacer nada.
                    HttpResponse<Void> r = cliente.send(peticionDe(n),
                            BodyHandlers.discarding());
                    sumaLatencias.add((System.nanoTime() - p0) / 1_000_000);
                    if (r.statusCode() == 200) {
                        correctas.incrementAndGet();
                    } else {
                        fallidas.incrementAndGet();
                    }
                } catch (IOException e) {
                    fallidas.incrementAndGet();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    llegada.countDown();
                }
            });
        }

        long t0 = System.currentTimeMillis();
        salida.countDown();
        llegada.await();
        long ms = System.currentTimeMillis() - t0;

        pool.shutdown();
        if (!pool.awaitTermination(5, TimeUnit.SECONDS)) {
            pool.shutdownNow();
        }

        return new Resultado("B. Pool de 8 hilos (send bloqueante)", ms,
                correctas.get(), fallidas.get(),
                (double) sumaLatencias.sum() / peticiones, vigilante.parar());
    }

    // =================================================================
    // C: asincrona sin limite
    // =================================================================

    public Resultado asincronaSinLimite() {
        VigilanteHilos vigilante = new VigilanteHilos();
        vigilante.arrancar();

        AtomicInteger correctas = new AtomicInteger();
        AtomicInteger fallidas = new AtomicInteger();
        LongAdder sumaLatencias = new LongAdder();

        long t0 = System.currentTimeMillis();
        List<CompletableFuture<Void>> futuros = new ArrayList<>(peticiones);

        for (int i = 0; i < peticiones; i++) {
            long p0 = System.nanoTime();
            futuros.add(cliente.sendAsync(peticionDe(i), BodyHandlers.discarding())
                    .thenAccept(r -> {
                        sumaLatencias.add((System.nanoTime() - p0) / 1_000_000);
                        if (r.statusCode() == 200) {
                            correctas.incrementAndGet();
                        } else {
                            fallidas.incrementAndGet();
                        }
                    })
                    // Blindaje individual: sin el, un fallo tumba el allOf.
                    .exceptionally(e -> {
                        fallidas.incrementAndGet();
                        return null;
                    }));
        }

        CompletableFuture.allOf(futuros.toArray(new CompletableFuture[0])).join();
        long ms = System.currentTimeMillis() - t0;

        return new Resultado("C. Asincrona sin limite (sendAsync + allOf)", ms,
                correctas.get(), fallidas.get(),
                (double) sumaLatencias.sum() / peticiones, vigilante.parar());
    }

    // =================================================================
    // D: asincrona acotada con Semaphore
    // =================================================================

    public Resultado asincronaAcotada(int simultaneas) {
        VigilanteHilos vigilante = new VigilanteHilos();
        vigilante.arrancar();

        AtomicInteger correctas = new AtomicInteger();
        AtomicInteger fallidas = new AtomicInteger();
        LongAdder sumaLatencias = new LongAdder();
        Semaphore permisos = new Semaphore(simultaneas);

        long t0 = System.currentTimeMillis();
        List<CompletableFuture<Void>> futuros = new ArrayList<>(peticiones);

        for (int i = 0; i < peticiones; i++) {
            try {
                // El semaforo limita cuantas peticiones hay EN VUELO,
                // no cuantos hilos hay. Es la diferencia con la estrategia B.
                permisos.acquire();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
            long p0 = System.nanoTime();
            futuros.add(cliente.sendAsync(peticionDe(i), BodyHandlers.discarding())
                    .thenAccept(r -> {
                        permisos.release();
                        sumaLatencias.add((System.nanoTime() - p0) / 1_000_000);
                        if (r.statusCode() == 200) {
                            correctas.incrementAndGet();
                        } else {
                            fallidas.incrementAndGet();
                        }
                    })
                    .exceptionally(e -> {
                        permisos.release();     // TAMBIEN al fallar, o se fuga
                        fallidas.incrementAndGet();
                        return null;
                    }));
        }

        CompletableFuture.allOf(futuros.toArray(new CompletableFuture[0])).join();
        long ms = System.currentTimeMillis() - t0;

        return new Resultado("D. Asincrona acotada a " + simultaneas, ms,
                correctas.get(), fallidas.get(),
                (double) sumaLatencias.sum() / peticiones, vigilante.parar());
    }

    // =================================================================
    // Ejecucion
    // =================================================================

    public void comparar() throws InterruptedException {
        // CALENTAMIENTO: la primera ronda carga clases, compila con el JIT
        // y establece las primeras conexiones. Sin descartarla, la primera
        // estrategia medida saldria injustamente penalizada.
        System.out.println("Calentando...");
        for (int i = 0; i < 5; i++) {
            try {
                cliente.send(peticionDe(i), BodyHandlers.discarding());
            } catch (Exception ignorada) {
                // El calentamiento no tiene que salir bien.
            }
        }

        System.out.println("Midiendo " + peticiones + " peticiones por estrategia...\n");

        List<Resultado> resultados = new ArrayList<>();
        resultados.add(secuencial());
        resultados.add(poolBloqueante());
        resultados.add(asincronaSinLimite());
        resultados.add(asincronaAcotada(8));

        long referencia = resultados.get(0).ms();

        System.out.printf("%-42s %9s %8s %10s %9s %8s%n",
                "ESTRATEGIA", "TIEMPO", "PET/S", "LAT.MEDIA", "HILOS", "MEJORA");
        System.out.println("-".repeat(95));
        for (Resultado r : resultados) {
            System.out.printf("%-42s %8d ms %8.0f %8.1f ms %9d %7.1fx%n",
                    r.estrategia(), r.ms(),
                    r.ms() == 0 ? 0 : peticiones * 1000.0 / r.ms(),
                    r.mediaLatenciaMs(), r.hilosMaximos(),
                    r.ms() == 0 ? 0 : (double) referencia / r.ms());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        String base = args.length > 0 ? args[0] : "http://localhost:8080";
        new ComparadorEstrategias(base, 50).comparar();
    }
}

Calentando...
Midiendo 50 peticiones por estrategia...

ESTRATEGIA                                    TIEMPO    PET/S  LAT.MEDIA     HILOS   MEJORA
-----------------------------------------------------------------------------------------------
A. Secuencial (send en bucle)                10214 ms        5    204.1 ms         9     1.0x
B. Pool de 8 hilos (send bloqueante)          1428 ms       35    221.6 ms        18     7.2x
C. Asincrona sin limite (sendAsync + allOf)    287 ms      174    263.4 ms        14    35.6x
D. Asincrona acotada a 8                      1391 ms       36    215.2 ms        12     7.3x

package com.nexussoftware.bibliotech.red;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.time.Duration;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Panel de estado de los servicios de los que depende BiblioTech.
 * Comprueba todos en paralelo cada N segundos y muestra un panel en consola.
 */
public class PanelEstadoServicios implements AutoCloseable {

    private static final Logger LOG =
            Logger.getLogger(PanelEstadoServicios.class.getName());

    private static final int HISTORIAL = 20;
    private static final int LIMITE_MS = 3_000;

    /** Un servicio a vigilar. */
    public record Servicio(String nombre, String url, int codigoEsperado) {
    }

    public enum Estado {
        ARRIBA('#'), DEGRADADO('-'), ABAJO('.');

        final char simbolo;

        Estado(char simbolo) {
            this.simbolo = simbolo;
        }
    }

    /** Resultado de una comprobacion. */
    public record Comprobacion(Estado estado, int codigo, long latenciaMs,
                               String version, String detalle) {
    }

    private final List<Servicio> servicios;
    private final HttpClient cliente;
    private final ScheduledExecutorService planificador;

    /**
     * Historial por servicio. ConcurrentHashMap porque lo escribe el hilo
     * del planificador y lo leen las etapas asincronas (08-06).
     */
    private final Map<String, Deque<Comprobacion>> historial = new ConcurrentHashMap<>();
    /** Ultimo estado conocido, para no repetir la alerta en cada ciclo. */
    private final Map<String, Estado> ultimoEstado = new ConcurrentHashMap<>();

    private final AtomicInteger ciclos = new AtomicInteger();

    public PanelEstadoServicios(List<Servicio> servicios) {
        this.servicios = servicios;

        AtomicInteger n = new AtomicInteger(1);
        this.cliente = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(2))
                .followRedirects(HttpClient.Redirect.NORMAL)
                .executor(Executors.newFixedThreadPool(servicios.size(), r -> {
                    Thread h = new Thread(r, "panel-http-" + n.getAndIncrement());
                    h.setDaemon(true);
                    return h;
                }))
                .build();

        this.planificador = Executors.newSingleThreadScheduledExecutor(r -> {
            Thread h = new Thread(r, "panel-planificador");
            h.setDaemon(true);
            return h;
        });

        for (Servicio s : servicios) {
            historial.put(s.nombre(), new ArrayDeque<>(HISTORIAL));
            ultimoEstado.put(s.nombre(), Estado.ARRIBA);
        }
    }

    // =================================================================
    // Arranque
    // =================================================================

    public void arrancar(int intervaloSegundos) {
        // scheduleAtFixedRate de 08-05.
        planificador.scheduleAtFixedRate(this::cicloSeguro,
                0, intervaloSegundos, TimeUnit.SECONDS);
        LOG.info("Panel de estado en marcha (cada " + intervaloSegundos + " s)");
    }

    /**
     * Envoltorio de seguridad OBLIGATORIO.
     *
     * Si una excepcion escapa de una tarea de scheduleAtFixedRate, la tarea
     * SE CANCELA EN SILENCIO y el panel deja de actualizarse sin que nadie
     * se entere: ni excepcion, ni log, ni nada. Es la trampa de 08-05.
     */
    private void cicloSeguro() {
        try {
            ciclo();
        } catch (RuntimeException e) {
            LOG.log(Level.SEVERE, "Fallo en el ciclo del panel", e);
        }
    }

    // =================================================================
    // Un ciclo de comprobacion
    // =================================================================

    private void ciclo() {
        long t0 = System.currentTimeMillis();

        // 1. Lanzar TODAS las comprobaciones en paralelo.
        List<CompletableFuture<Void>> futuros = new ArrayList<>(servicios.size());
        for (Servicio s : servicios) {
            futuros.add(comprobar(s));
        }

        // 2. Esperar a todas. join() aqui bloquea el hilo del planificador,
        //    que es lo correcto: no queremos pintar el panel a medias ni
        //    solapar dos ciclos.
        CompletableFuture.allOf(futuros.toArray(new CompletableFuture[0])).join();

        ciclos.incrementAndGet();
        pintar(System.currentTimeMillis() - t0);
    }

    private CompletableFuture<Void> comprobar(Servicio servicio) {
        HttpRequest peticion = HttpRequest.newBuilder()
                .uri(URI.create(servicio.url()))
                .header("User-Agent", "BiblioTech-Panel/1.0")
                .header("Accept", "*/*")
                .timeout(Duration.ofMillis(LIMITE_MS))      // limite TOTAL
                .GET()
                .build();

        long inicio = System.nanoTime();

        // discarding(): solo interesa el codigo, no el cuerpo. Pero lo
        // CONSUME, que es lo que permite reutilizar la conexion.
        return cliente.sendAsync(peticion, BodyHandlers.discarding())
                .thenAccept(respuesta -> {
                    long ms = (System.nanoTime() - inicio) / 1_000_000;
                    int codigo = respuesta.statusCode();

                    Estado estado = codigo == servicio.codigoEsperado()
                            ? Estado.ARRIBA
                            : Estado.DEGRADADO;

                    registrar(servicio, new Comprobacion(estado, codigo, ms,
                            respuesta.version().toString(),
                            estado == Estado.DEGRADADO
                                    ? "esperabamos " + servicio.codigoEsperado() : ""));
                })
                // Blindaje individual: un servicio caido no puede impedir
                // que se comprueben los demas ni que se pinte el panel.
                .exceptionally(e -> {
                    long ms = (System.nanoTime() - inicio) / 1_000_000;
                    Throwable causa = e.getCause() != null ? e.getCause() : e;
                    registrar(servicio, new Comprobacion(Estado.ABAJO, -1, ms,
                            "-", causa.getClass().getSimpleName()));
                    return null;
                });
    }

    private void registrar(Servicio servicio, Comprobacion c) {
        Deque<Comprobacion> cola = historial.get(servicio.nombre());
        synchronized (cola) {       // ArrayDeque no es segura para varios hilos
            if (cola.size() >= HISTORIAL) {
                cola.removeFirst();
            }
            cola.addLast(c);
        }

        // Alerta SOLO en el cambio de estado, no en cada ciclo: un
        // servicio caido durante una hora generaria 360 alertas identicas.
        Estado anterior = ultimoEstado.put(servicio.nombre(), c.estado());
        if (anterior != c.estado()) {
            if (c.estado() == Estado.ABAJO) {
                LOG.severe("ALERTA: " + servicio.nombre() + " ha CAIDO ("
                        + c.detalle() + ")");
            } else if (anterior == Estado.ABAJO) {
                LOG.info("RECUPERADO: " + servicio.nombre() + " vuelve a responder");
            } else {
                LOG.warning("CAMBIO: " + servicio.nombre() + " " + anterior
                        + " -> " + c.estado());
            }
        }
    }

    // =================================================================
    // Pintado
    // =================================================================

    private void pintar(long msCiclo) {
        StringBuilder sb = new StringBuilder();
        sb.append("\033[H\033[2J");     // limpiar pantalla
        sb.append("=== PANEL DE ESTADO - BIBLIOTECH ===\n");
        sb.append(String.format("Ciclo %d   comprobacion en %d ms%n%n",
                ciclos.get(), msCiclo));
        sb.append(String.format("%-22s %-11s %7s %6s %-9s %-22s %7s%n",
                "SERVICIO", "ESTADO", "LATENCIA", "CODIGO", "VERSION",
                "HISTORIAL", "DISPON."));
        sb.append("-".repeat(96)).append('\n');

        for (Servicio s : servicios) {
            Deque<Comprobacion> cola = historial.get(s.nombre());
            List<Comprobacion> copia;
            synchronized (cola) {
                copia = new ArrayList<>(cola);
            }
            if (copia.isEmpty()) {
                continue;
            }
            Comprobacion ultima = copia.get(copia.size() - 1);

            // Barra de historial y calculo de disponibilidad.
            StringBuilder barra = new StringBuilder();
            int arriba = 0;
            for (Comprobacion c : copia) {
                barra.append(c.estado().simbolo);
                if (c.estado() == Estado.ARRIBA) {
                    arriba++;
                }
            }
            double disponibilidad = 100.0 * arriba / copia.size();

            sb.append(String.format("%-22s %-11s %6d ms %6s %-9s %-22s %6.1f%%%n",
                    s.nombre(),
                    ultima.estado(),
                    ultima.latenciaMs(),
                    ultima.codigo() < 0 ? "-" : String.valueOf(ultima.codigo()),
                    ultima.version().replace("HTTP_", "HTTP/"),
                    barra,
                    disponibilidad));

            if (!ultima.detalle().isEmpty()) {
                sb.append(String.format("  %-20s %s%n", "", ultima.detalle()));
            }
        }

        sb.append("-".repeat(96)).append('\n');
        sb.append("Leyenda: # arriba   - degradado   . abajo\n");
        System.out.print(sb);
    }

    @Override
    public void close() {
        // Apagado en dos fases (08-05).
        planificador.shutdown();
        try {
            if (!planificador.awaitTermination(5, TimeUnit.SECONDS)) {
                planificador.shutdownNow();
            }
        } catch (InterruptedException e) {
            planificador.shutdownNow();
            Thread.currentThread().interrupt();      // 08-02
        }
        LOG.info("Panel de estado detenido tras " + ciclos.get() + " ciclos");
    }

    // =================================================================
    // Arranque
    // =================================================================

    public static void main(String[] args) throws InterruptedException {
        List<Servicio> servicios = List.of(
                new Servicio("catalogo-btcp", "http://localhost:9092/", 200),
                new Servicio("metadatos", "http://localhost:8080/salud", 200),
                new Servicio("portadas", "http://localhost:8081/salud", 200),
                new Servicio("avisos", "http://localhost:8082/salud", 200),
                new Servicio("inexistente", "http://localhost:9999/salud", 200));

        PanelEstadoServicios panel = new PanelEstadoServicios(servicios);

        // Shutdown hook: Ctrl+C, SIGTERM de Docker o systemd (09-03).
        Runtime.getRuntime().addShutdownHook(
                new Thread(panel::close, "panel-apagado"));

        panel.arrancar(10);

        // El planificador usa hilos daemon: hay que mantener vivo el main.
        Thread.currentThread().join();
    }
}

=== PANEL DE ESTADO - BIBLIOTECH ===
Ciclo 14   comprobacion en 3012 ms

SERVICIO               ESTADO      LATENCIA CODIGO VERSION   HISTORIAL              DISPON.
------------------------------------------------------------------------------------------------
catalogo-btcp          ARRIBA            4 ms    200 HTTP/1_1  ##############          100.0%
metadatos              ARRIBA           38 ms    200 HTTP/2    #############-           92.9%
  esperabamos 200
portadas               ARRIBA           21 ms    200 HTTP/2    ##############          100.0%
avisos                 DEGRADADO       104 ms    503 HTTP/1_1  ###########---           78.6%
  esperabamos 200
inexistente            ABAJO          2001 ms      - -         ..............            0.0%
  ConnectException
------------------------------------------------------------------------------------------------
Leyenda: # arriba   - degradado   . abajo