{
  "isbn": "978-0000000001",
  "titulo": "Java Efectivo",
  "autor": "Joshua Bloch",
  "anioPublicacion": 2018,
  "disponible": true,
  "categorias": ["Java", "Buenas prácticas"],
  "editorial": {
    "nombre": "Addison-Wesley",
    "pais": "EE. UU."
  },
  "fechaAlta": "2026-01-15",
  "valoracion": null
}

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <!-- sin version: la gestiona el BOM de Spring Boot (11-05) -->
</dependency>

<!-- Soporte para java.time (apartado 10) -->
<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
</dependency>

// MAL: crea un mapper en cada llamada. Tira el caché a la basura cada vez.
public String aJson(Material material) {
    return new ObjectMapper().writeValueAsString(material);   // lento y con basura
}

// BIEN: uno solo, compartido
private static final ObjectMapper MAPPER = new ObjectMapper();

public String aJson(Material material) {
    return MAPPER.writeValueAsString(material);
}

@Service
public class ExportadorCatalogo {

    private final ObjectMapper mapper;   // Spring inyecta el suyo, ya configurado

    public ExportadorCatalogo(ObjectMapper mapper) {
        this.mapper = mapper;
    }
}

package com.nexussoftware.bibliotech.persistencia;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.JsonProcessingException;

public class ExportadorJson {

    private final ObjectMapper mapper;

    public ExportadorJson(ObjectMapper mapper) { this.mapper = mapper; }

    public String exportar(Material material) {
        try {
            return mapper.writeValueAsString(material);
        } catch (JsonProcessingException e) {
            // Estrategia por capas del módulo 6: envolver, conservar la causa
            throw new ExportacionException("No se pudo serializar " + material.getIsbn(), e);
        }
    }

    public String exportarLegible(Material material) {
        try {
            return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(material);
        } catch (JsonProcessingException e) {
            throw new ExportacionException("No se pudo serializar", e);
        }
    }

    public void exportarAFichero(List<Material> catalogo, Path destino) throws IOException {
        mapper.writeValue(destino.toFile(), catalogo);      // sin cargarlo todo en memoria
    }
}

{"isbn":"978-0000000001","titulo":"Java Efectivo","autor":"Joshua Bloch","ejemplaresDisponibles":3}

{
  "isbn" : "978-0000000001",
  "titulo" : "Java Efectivo",
  "autor" : "Joshua Bloch",
  "ejemplaresDisponibles" : 3
}

public Material importar(String json) {
    try {
        return mapper.readValue(json, Libro.class);
    } catch (JsonProcessingException e) {
        throw new ImportacionException("JSON de material inválido", e);
    }
}

Libro desdeCadena  = mapper.readValue(json, Libro.class);
Libro desdeFichero = mapper.readValue(Path.of("libro.json").toFile(), Libro.class);
Libro desdeFlujo   = mapper.readValue(entrada, Libro.class);
Libro desdeUrl     = mapper.readValue(new URL("https://..."), Libro.class);

com.fasterxml.jackson.databind.exc.InvalidDefinitionException:
Cannot construct instance of `com.nexussoftware.bibliotech.dominio.Libro`
(no Creators, like default constructor, exist)

public class MetadatosLibro {

    private String isbn;
    private String titulo;
    private String autor;
    private int anioPublicacion;

    public MetadatosLibro() { }   // exigido por Jackson

    // getters y setters...
}

public record MetadatosLibro(String isbn, String titulo, String autor, int anioPublicacion) { }

public record MetadatosLibro(
        String isbn,
        String titulo,
        Autor autor,                    // objeto anidado
        List<String> categorias,        // array
        LocalDate fechaPublicacion) {   // fecha ISO (apartado 10)

    public record Autor(String nombre, String pais) { }
}

{
  "isbn": "978-0000000001",
  "titulo": "Java Efectivo",
  "autor": { "nombre": "Joshua Bloch", "pais": "EE. UU." },
  "categorias": ["Java", "Buenas prácticas"],
  "fechaPublicacion": "2018-01-06"
}

package com.nexussoftware.bibliotech.red;

import com.fasterxml.jackson.annotation.*;
import java.time.LocalDate;
import java.util.List;

@JsonIgnoreProperties(ignoreUnknown = true)      // imprescindible: apartado 8
@JsonInclude(JsonInclude.Include.NON_NULL)       // no serializar nulos
public record RespuestaMetadatos(

        @JsonProperty("isbn_13")                 // la API usa snake_case
        String isbn,

        @JsonAlias({"title", "book_title"})      // la API cambió el nombre en v2
        String titulo,

        @JsonProperty("authors")
        List<String> autores,

        @JsonProperty("publish_date")
        @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
        LocalDate fechaPublicacion,

        @JsonProperty("number_of_pages")
        Integer paginas) {
}

public class UsuarioDto {
    private String correo;

    @JsonIgnore
    private String hashContrasena;   // NUNCA debe salir en una respuesta
}

public record MetadatosLibro(String isbn, String titulo) { }

{
  "isbn": "978-0000000001",
  "titulo": "Java Efectivo",
  "idioma": "es"
}

com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException:
Unrecognized field "idioma" (class MetadatosLibro), not marked as ignorable

@JsonIgnoreProperties(ignoreUnknown = true)
public record MetadatosLibro(String isbn, String titulo) { }

mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

spring:
  jackson:
    deserialization:
      fail-on-unknown-properties: false   # valor por defecto en Spring Boot

// NO FUNCIONA como esperas
List<MetadatosLibro> lista = mapper.readValue(json, List.class);
// -> devuelve List<LinkedHashMap>, y estalla al usarlo:
// ClassCastException: LinkedHashMap cannot be cast to MetadatosLibro

List<MetadatosLibro> lista = mapper.readValue(json,
        new TypeReference<List<MetadatosLibro>>() { });

// Lista
List<Material> materiales = mapper.readValue(json, new TypeReference<>() { });

// Mapa
Map<String, List<Prestamo>> porEmpleado = mapper.readValue(json, new TypeReference<>() { });

// Genérico propio: el Resultado<T> de 10-01
Resultado<Material> resultado = mapper.readValue(json, new TypeReference<Resultado<Material>>() { });

JavaType tipo = mapper.getTypeFactory().constructCollectionType(List.class, Material.class);
List<Material> materiales = mapper.readValue(json, tipo);

com.fasterxml.jackson.databind.exc.InvalidDefinitionException:
Java 8 date/time type `java.time.LocalDate` not supported by default:
add Module "com.fasterxml.jackson.datatype:jackson-datatype-jsr310"

ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JavaTimeModule());
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);   // ¡importante!

ObjectMapper mapper = JsonMapper.builder()
        .findAndAddModules()
        .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
        .build();

// Activado (valor por defecto de Jackson): número de segundos desde 1970
{"instanteRegistro": 1774000800.000000000}

// Desactivado: ISO-8601, legible e interoperable
{"instanteRegistro": "2026-03-20T09:00:00Z"}

spring:
  jackson:
    serialization:
      write-dates-as-timestamps: false
    time-zone: Europe/Madrid
    default-property-inclusion: non_null

CsvMapper mapper = new CsvMapper();
CsvSchema esquema = mapper.schemaFor(MaterialCsv.class).withHeader().withColumnSeparator(';');

// Escribir
mapper.writer(esquema).writeValue(fichero, materiales);

// Leer
List<MaterialCsv> materiales = mapper.readerFor(MaterialCsv.class)
        .with(esquema).<MaterialCsv>readValues(fichero).readAll();

JsonNode raiz = mapper.readTree(json);

String titulo = raiz.path("titulo").asText();
int anio      = raiz.path("anioPublicacion").asInt(0);          // 0 si falta
String pais   = raiz.path("editorial").path("pais").asText("Desconocido");

// Recorrer un array
for (JsonNode categoria : raiz.path("categorias")) {
    System.out.println(categoria.asText());
}

// Comprobar existencia
if (raiz.has("valoracion") && !raiz.get("valoracion").isNull()) {
    double valoracion = raiz.get("valoracion").asDouble();
}

// Construir JSON a mano
ObjectNode nuevo = mapper.createObjectNode();
nuevo.put("isbn", "978-0000000001");
nuevo.put("titulo", "Java Efectivo");
nuevo.putArray("categorias").add("Java").add("Buenas prácticas");
String json = mapper.writeValueAsString(nuevo);

// Sin serializador propio: {"isbn": {"valor": "978-0000000001"}}
// Con serializador propio: {"isbn": "978-0000000001"}

package com.nexussoftware.bibliotech.persistencia;

import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import java.io.IOException;

public class SerializadorIsbn extends JsonSerializer<Isbn> {
    @Override
    public void serialize(Isbn isbn, JsonGenerator gen, SerializerProvider sp)
            throws IOException {
        gen.writeString(isbn.valor());
    }
}

public class DeserializadorIsbn extends JsonDeserializer<Isbn> {
    @Override
    public Isbn deserialize(JsonParser p, DeserializationContext ctx) throws IOException {
        String texto = p.getText();
        try {
            return new Isbn(texto);          // la validación del record actúa aquí
        } catch (IsbnInvalidoException e) {
            throw JsonMappingException.from(p, "ISBN inválido: " + texto, e);
        }
    }
}

// Opción 1: en el campo
public record MaterialDto(
        @JsonSerialize(using = SerializadorIsbn.class)
        @JsonDeserialize(using = DeserializadorIsbn.class)
        Isbn isbn,
        String titulo) { }

// Opción 2: en un módulo, aplicado a TODOS los Isbn
SimpleModule modulo = new SimpleModule("BiblioTech");
modulo.addSerializer(Isbn.class, new SerializadorIsbn());
modulo.addDeserializer(Isbn.class, new DeserializadorIsbn());
mapper.registerModule(modulo);

@Bean
public Module moduloBiblioTech() {
    SimpleModule modulo = new SimpleModule("BiblioTech");
    modulo.addSerializer(Isbn.class, new SerializadorIsbn());
    modulo.addDeserializer(Isbn.class, new DeserializadorIsbn());
    return modulo;
}

// 09-06: el "apaño didáctico" reconocido como tal
public class ClienteMetadatos {

    public Optional<String> extraerTitulo(String json) {
        int inicio = json.indexOf("\"title\":\"");
        if (inicio < 0) return Optional.empty();
        inicio += 9;
        int fin = json.indexOf("\"", inicio);
        if (fin < 0) return Optional.empty();
        return Optional.of(json.substring(inicio, fin));
    }

    public Optional<String> extraerAutor(String json) {
        // ... lo mismo, otra vez
    }
}

package com.nexussoftware.bibliotech.red;

import com.fasterxml.jackson.annotation.*;
import java.time.LocalDate;
import java.util.List;

/** Respuesta de la API externa de metadatos. Es un DTO: refleja el JSON, no el dominio. */
@JsonIgnoreProperties(ignoreUnknown = true)   // la API puede añadir campos cuando quiera
public record RespuestaMetadatos(

        @JsonProperty("isbn_13")     String isbn,
        @JsonAlias({"title"})        String titulo,
        @JsonProperty("authors")     List<Autor> autores,
        @JsonProperty("publish_date") LocalDate fechaPublicacion,
        @JsonProperty("number_of_pages") Integer paginas,
        @JsonProperty("publishers")  List<String> editoriales) {

    @JsonIgnoreProperties(ignoreUnknown = true)
    public record Autor(String name, String key) { }

    /** Traduce el DTO externo al modelo de dominio de BiblioTech. */
    public MetadatosLibro aDominio() {
        String autoresUnidos = autores == null ? null
                : autores.stream().map(Autor::name).collect(Collectors.joining(", "));
        String editorial = editoriales == null || editoriales.isEmpty()
                ? null : editoriales.get(0);
        return new MetadatosLibro(autoresUnidos, fechaPublicacion, editorial, paginas);
    }
}

package com.nexussoftware.bibliotech.red;

import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.*;
import java.time.Duration;
import java.util.Optional;
import org.slf4j.*;
import org.springframework.stereotype.Component;

@Component
public class PasarelaMetadatosHttp implements PasarelaMetadatos {

    private static final Logger log = LoggerFactory.getLogger(PasarelaMetadatosHttp.class);

    private final HttpClient http;          // uno solo, inyectado (11-02)
    private final ObjectMapper mapper;      // uno solo, inyectado
    private final String urlBase;

    public PasarelaMetadatosHttp(HttpClient http, ObjectMapper mapper,
                                 @Value("${bibliotech.metadatos.url}") String urlBase) {
        this.http = http;
        this.mapper = mapper;
        this.urlBase = urlBase;
    }

    @Override
    public Optional<MetadatosLibro> buscarPorIsbn(String isbn) {

        HttpRequest peticion = HttpRequest.newBuilder()
                .uri(URI.create(urlBase + "/isbn/" + isbn + ".json"))
                .header("Accept", "application/json")
                .timeout(Duration.ofSeconds(5))
                .GET()
                .build();

        try {
            HttpResponse<String> respuesta =
                    http.send(peticion, HttpResponse.BodyHandlers.ofString());

            if (respuesta.statusCode() == 404) {
                log.debug("La API no conoce el ISBN {}", isbn);
                return Optional.empty();
            }
            if (respuesta.statusCode() >= 500) {
                throw new PasarelaNoDisponibleException(
                        "La API devolvió " + respuesta.statusCode());
            }

            // UNA LÍNEA. Sin indexOf, sin substring, sin casos límite sin cubrir.
            RespuestaMetadatos dto = mapper.readValue(respuesta.body(), RespuestaMetadatos.class);

            log.info("Metadatos obtenidos para {}: {}", isbn, dto.titulo());
            return Optional.of(dto.aDominio());

        } catch (JsonProcessingException e) {
            log.warn("Respuesta JSON inválida para {}", isbn, e);
            throw new PasarelaNoDisponibleException("Respuesta ilegible de la API", e);
        } catch (IOException | InterruptedException e) {
            if (e instanceof InterruptedException) Thread.currentThread().interrupt();
            throw new PasarelaNoDisponibleException("Error de red al consultar " + isbn, e);
        }
    }
}

// PELIGROSO con datos externos
mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                             ObjectMapper.DefaultTyping.NON_FINAL);

{"@class": "com.ejemplo.ClasePeligrosa", "propiedad": "valor"}

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "tipo")
@JsonSubTypes({
    @JsonSubTypes.Type(value = LibroDto.class,   name = "LIBRO"),
    @JsonSubTypes.Type(value = RevistaDto.class, name = "REVISTA"),
    @JsonSubTypes.Type(value = DvdDto.class,     name = "DVD")
})
public sealed interface MaterialDto permits LibroDto, RevistaDto, DvdDto { }

public class Empleado {

    private Long id;
    private String correo;
    private String nombre;
    private String departamento;

    public Empleado() { }

    public Empleado(String correo, String nombre, String departamento) {
        this.correo = correo;
        this.nombre = nombre;
        this.departamento = departamento;
    }

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getCorreo() { return correo; }
    public void setCorreo(String correo) { this.correo = correo; }
    public String getNombre() { return nombre; }
    public void setNombre(String nombre) { this.nombre = nombre; }
    public String getDepartamento() { return departamento; }
    public void setDepartamento(String departamento) { this.departamento = departamento; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Empleado)) return false;
        Empleado otro = (Empleado) o;
        return Objects.equals(correo, otro.correo);
    }

    @Override
    public int hashCode() { return Objects.hash(correo); }

    @Override
    public String toString() {
        return "Empleado{correo='" + correo + "', nombre='" + nombre + "'}";
    }
}

@Getter @Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(of = "correo")
@ToString(of = {"correo", "nombre"})
public class Empleado {
    private Long id;
    private String correo;
    private String nombre;
    private String departamento;
}

javap -p target/classes/com/nexussoftware/bibliotech/dominio/Empleado.class

public class com.nexussoftware.bibliotech.dominio.Empleado {
  private java.lang.Long id;
  private java.lang.String correo;
  public java.lang.Long getId();
  public void setId(java.lang.Long);
  public java.lang.String getCorreo();
  ...
}

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <scope>provided</scope>   <!-- solo en compilación (11-05) -->
    <optional>true</optional>
</dependency>

@Slf4j
@Service
public class GestorPrestamos {
    public void prestar(String isbn) {
        log.info("Prestando {}", isbn);      // 'log' existe, generado por Lombok
    }
}

@SneakyThrows
public String leer(Path fichero) {
    return Files.readString(fichero);   // IOException no declarada
}

@Builder
@Getter
public class Prestamo {
    private final Material material;
    private final Empleado empleado;
    private final LocalDate fechaPrestamo;
    private final LocalDate fechaVencimiento;
    @Builder.Default
    private final EstadoPrestamo estado = EstadoPrestamo.ACTIVO;
}

Prestamo prestamo = Prestamo.builder()
        .material(libro)
        .empleado(marta)
        .fechaPrestamo(LocalDate.now(reloj))
        .fechaVencimiento(LocalDate.now(reloj).plusDays(15))
        .build();

@Service
@RequiredArgsConstructor        // constructor con TODOS los campos final
public class GestorPrestamos {

    private final MaterialRepository materiales;
    private final EmpleadoRepository empleados;
    private final PrestamoRepository prestamos;
    private final CalculadoraMultas calculadora;
    private final ServicioAvisos avisos;
    private final Clock reloj;

    // El constructor de 6 parámetros lo genera Lombok
}

# Detiene la búsqueda de configuración en directorios superiores
config.stopBubbling = true

# Añade @lombok.Generated a lo generado: JaCoCo lo EXCLUYE de la cobertura (12-05)
lombok.addLombokGeneratedAnnotation = true

# Prohíbe @Data y @Value: obligan a ser explícito (ver apartado 21)
lombok.data.flagUsage = error
lombok.value.flagUsage = warning

# Prohíbe @SneakyThrows: rompe el contrato de excepciones del módulo 6
lombok.sneakyThrows.flagUsage = error

# Copia estas anotaciones al constructor generado (útil con Spring y Jackson)
lombok.copyableAnnotations += org.springframework.beans.factory.annotation.Qualifier

// LO QUE NO HAY QUE HACER
@Entity
@Data                       // <- incluye @EqualsAndHashCode con TODOS los campos
public class Material {

    @Id @GeneratedValue
    private Long id;

    private String isbn;
    private String titulo;

    @OneToMany(mappedBy = "material", fetch = FetchType.LAZY)
    private List<Prestamo> prestamos;
}

Material libro = new Libro("978-0000000001", "Java Efectivo", 3, "J. Bloch");
Set<Material> conjunto = new HashSet<>();
conjunto.add(libro);                        // id = null -> hashCode X

repositorio.save(libro);                    // JPA asigna id = 42 -> hashCode Y

assertThat(conjunto.contains(libro));       // ¡FALSE! Está en el cubo equivocado

log.debug("Material: {}", material);
// -> toString() llama a getPrestamos()
// -> se inicializa la colección perezosa
// -> SELECT * FROM prestamo WHERE material_id = 42

@Entity
@Getter                                       // solo getters
@Setter(AccessLevel.PROTECTED)                // setters restringidos
@NoArgsConstructor(access = AccessLevel.PROTECTED)   // el que exige JPA
@ToString(of = { "id", "isbn", "titulo" })    // SOLO campos escalares
@EqualsAndHashCode(of = "isbn")               // SOLO la clave de negocio, inmutable
public class Material {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String isbn;                      // clave de negocio: nunca cambia

    private String titulo;

    @OneToMany(mappedBy = "material", fetch = FetchType.LAZY)
    private List<Prestamo> prestamos = new ArrayList<>();
}

// Lombok
@Value
public class MetadatosLibro {
    String autor;
    LocalDate fechaPublicacion;
    String editorial;
}

// Java 16+, sin dependencias
public record MetadatosLibro(String autor, LocalDate fechaPublicacion, String editorial) { }

package com.nexussoftware.bibliotech.servicio;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class GestorPrestamos {

    private static final Logger log = LoggerFactory.getLogger(GestorPrestamos.class);

    public Prestamo prestar(String isbn, String correo) {
        log.debug("Solicitud de préstamo: isbn={}, empleado={}", isbn, correo);
        // ...
        log.info("Préstamo creado: id={}, vence={}", prestamo.getId(), prestamo.getFechaVencimiento());
        return prestamo;
    }
}

logging.level.com.nexussoftware.bibliotech=DEBUG
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.springframework=INFO

@Slf4j
public class GestorPrestamos { ... }

// MAL: concatenación
log.debug("Préstamo " + prestamo.getId() + " del material " + material.getTitulo()
          + " para " + empleado.getNombre());

// BIEN: parametrizado
log.debug("Préstamo {} del material {} para {}",
          prestamo.getId(), material.getTitulo(), empleado.getNombre());

// Excepciones: SIEMPRE como ÚLTIMO argumento, SIN {}
log.error("No se pudo prestar {}", isbn, excepcion);   // registra la traza completa

// MAL: pierde la traza de pila, que es lo único útil
log.error("No se pudo prestar " + isbn + ": " + excepcion.getMessage());

// Si el argumento es CARO de calcular, comprueba el nivel
if (log.isDebugEnabled()) {
    log.debug("Estado completo del catálogo: {}", catalogo.volcadoCompleto());
}

log.atDebug().setMessage("Catálogo: {}")
   .addArgument(() -> catalogo.volcadoCompleto())   // lambda: solo se evalúa si hace falta
   .log();

// ERROR: hay que actuar. Alguien debería recibir una alerta.
log.error("No se pudo conectar con la base de datos tras 3 intentos", excepcion);

// WARN: anómalo pero recuperado.
log.warn("La API de metadatos no respondió para {}; se continúa sin enriquecer", isbn);

// INFO: eventos de negocio. Debe poder leerse en producción sin ruido.
log.info("Préstamo {} creado para {} con vencimiento {}", id, correo, vencimiento);

// DEBUG: para diagnosticar. Desactivado en producción.
log.debug("Evaluando {} reservas pendientes con antelación de {} días", total, dias);

// TRACE: muy fino. Casi nunca activado.
log.trace("Reserva {} : fechaSolicitud={}, caduca={}", id, solicitud, caducidad);

// MAL: la misma excepción aparecerá tres veces en el log
catch (IOException e) {
    log.error("Error al leer", e);
    throw new PersistenciaException("Error al leer", e);
}

// BIEN: o registras (porque aquí se maneja) o relanzas (y registra quien maneje)
catch (IOException e) {
    throw new PersistenciaException("Error al leer " + fichero, e);
}

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <property name="PATRON_CONSOLA"
              value="%d{HH:mm:ss.SSS} %highlight(%-5level) [%thread] %cyan(%logger{36}) - %msg%n"/>
    <property name="PATRON_FICHERO"
              value="%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{40} [%X{idPeticion}] - %msg%n"/>

    <!-- APPENDER 1: consola -->
    <appender name="CONSOLA" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${PATRON_CONSOLA}</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- APPENDER 2: fichero con rotación por fecha Y tamaño -->
    <appender name="FICHERO" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/bibliotech.log</file>
        <encoder>
            <pattern>${PATRON_FICHERO}</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>logs/bibliotech-%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <maxFileSize>50MB</maxFileSize>      <!-- rota al superar 50 MB -->
            <maxHistory>30</maxHistory>          <!-- conserva 30 días -->
            <totalSizeCap>2GB</totalSizeCap>     <!-- nunca más de 2 GB en total -->
        </rollingPolicy>
    </appender>

    <!-- APPENDER 3: asíncrono. No bloquea el hilo de negocio al escribir -->
    <appender name="FICHERO_ASINCRONO" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="FICHERO"/>
        <queueSize>512</queueSize>
        <discardingThreshold>0</discardingThreshold>   <!-- no descartar mensajes -->
    </appender>

    <!-- NIVELES POR PAQUETE -->
    <logger name="com.nexussoftware.bibliotech" level="DEBUG"/>
    <logger name="org.hibernate.SQL" level="DEBUG"/>
    <logger name="org.hibernate.orm.jdbc.bind" level="TRACE"/>
    <logger name="org.springframework" level="INFO"/>

    <!-- PERFILES DE SPRING (11-02) -->
    <springProfile name="dev">
        <root level="DEBUG">
            <appender-ref ref="CONSOLA"/>
        </root>
    </springProfile>

    <springProfile name="prod">
        <root level="INFO">
            <appender-ref ref="FICHERO_ASINCRONO"/>
        </root>
        <logger name="com.nexussoftware.bibliotech" level="INFO"/>
        <logger name="org.hibernate.SQL" level="OFF"/>
    </springProfile>

</configuration>

logging:
  level:
    root: INFO
    com.nexussoftware.bibliotech: DEBUG
    org.hibernate.SQL: DEBUG
  file:
    name: logs/bibliotech.log
  logback:
    rollingpolicy:
      max-file-size: 50MB
      max-history: 30
  pattern:
    console: "%d{HH:mm:ss.SSS} %-5level %logger{36} - %msg%n"

import org.slf4j.MDC;

public class FiltroCorrelacion implements Filter {

    @Override
    public void doFilter(ServletRequest peticion, ServletResponse respuesta, FilterChain cadena)
            throws IOException, ServletException {

        String idPeticion = Optional
                .ofNullable(((HttpServletRequest) peticion).getHeader("X-Request-Id"))
                .orElse(UUID.randomUUID().toString());

        MDC.put("idPeticion", idPeticion);
        MDC.put("usuario", usuarioActual());

        try {
            cadena.doFilter(peticion, respuesta);
        } finally {
            MDC.clear();   // IMPRESCINDIBLE: el hilo vuelve al pool (módulo 8)
        }
    }
}

2026-03-20 10:15:23.451 INFO  [http-nio-8080-exec-3] c.n.b.s.GestorPrestamos [a3f2-9b21] - Préstamo 4218 creado
2026-03-20 10:15:23.502 DEBUG [http-nio-8080-exec-3] c.n.b.p.PrestamoRepository [a3f2-9b21] - Guardando préstamo
2026-03-20 10:15:23.510 INFO  [http-nio-8080-exec-7] c.n.b.s.GestorPrestamos [7c81-4e55] - Préstamo 4219 creado

{"@timestamp":"2026-03-20T10:15:23.451+01:00","level":"INFO","logger":"com.nexussoftware.bibliotech.servicio.GestorPrestamos","thread":"http-nio-8080-exec-3","message":"Préstamo 4218 creado","idPeticion":"a3f2-9b21","usuario":"[email protected]"}

<appender name="JSON" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="net.logstash.logback.encoder.LogstashEncoder">
        <includeMdcKeyName>idPeticion</includeMdcKeyName>
        <includeMdcKeyName>usuario</includeMdcKeyName>
    </encoder>
</appender>

logging:
  structured:
    format:
      console: ecs      # Elastic Common Schema

import java.util.logging.Level;
import java.util.logging.Logger;

public class GestorPrestamos {

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

    public Prestamo prestar(String isbn, String correo) {
        if (LOG.isLoggable(Level.FINE)) {                     // comprobación manual
            LOG.fine("Prestando " + isbn + " a " + correo);   // concatenación
        }
        try {
            // ...
            LOG.info("Préstamo creado: " + prestamo.getId());
            return prestamo;
        } catch (Exception e) {
            LOG.log(Level.SEVERE, "Error al prestar " + isbn, e);   // API incómoda
            throw e;
        }
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class GestorPrestamos {

    private static final Logger log = LoggerFactory.getLogger(GestorPrestamos.class);

    public Prestamo prestar(String isbn, String correo) {
        log.debug("Prestando {} a {}", isbn, correo);          // parametrizado, diferido

        Prestamo prestamo = /* ... */;
        log.info("Préstamo creado: id={}, vence={}",
                 prestamo.getId(), prestamo.getFechaVencimiento());
        return prestamo;
    }
}

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jul-to-slf4j</artifactId>
</dependency>

./mvnw dependency:tree | grep -E "slf4j|logback|log4j"

SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [.../logback-classic-1.5.6.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [.../slf4j-simple-2.0.13.jar!/org/slf4j/impl/StaticLoggerBinder.class]

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

// Tu LectorCsv de 07-07: 70 líneas, sin cubrir comillas ni saltos embebidos
// Con OpenCSV:
try (var lector = new CsvToBeanBuilder<MaterialCsv>(new FileReader(fichero, UTF_8))
        .withType(MaterialCsv.class)
        .withSeparator(';')
        .build()) {
    List<MaterialCsv> materiales = lector.parse();
}

@Mapper(componentModel = "spring")
public interface MaterialMapper {
    MaterialDto aDto(Material material);
    List<MaterialDto> aDtos(List<Material> materiales);
}

@Test
void elDominioNoDependeDeSpringNiDeJpa() {
    JavaClasses clases = new ClassFileImporter()
            .importPackages("com.nexussoftware.bibliotech");

    noClasses().that().resideInAPackage("..dominio..")
            .should().dependOnClassesThat()
            .resideInAnyPackage("org.springframework..", "jakarta.persistence..")
            .check(clases);
}

{
  "request_id": "req-8821",
  "generated_at": "2026-03-20T10:15:23Z",
  "items": [
    {
      "isbn_13": "978-0000000001",
      "book_title": "Java Efectivo",
      "stock": { "available": 3, "reserved": 1, "warehouse": "MAD-01" },
      "unit_price": 54.95,
      "currency": "EUR",
      "last_updated": "2026-03-19",
      "tags": ["java", "best-practices"],
      "discontinued": false
    }
  ],
  "warnings": []
}

@Entity
@Table(name = "material")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Material {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String isbn;

    private String titulo;

    private int ejemplaresDisponibles = 1;

    @OneToMany(mappedBy = "material", fetch = FetchType.LAZY)
    private List<Prestamo> prestamos = new ArrayList<>();

    @ManyToMany(fetch = FetchType.LAZY)
    private Set<Categoria> categorias = new HashSet<>();

    @Version
    private Long version;
}

public class GestorDevoluciones {

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

    public ResultadoDevolucion devolver(Long prestamoId) {

        LOG.info("Iniciando devolución del préstamo " + prestamoId);

        Prestamo prestamo = prestamos.findById(prestamoId).orElse(null);
        if (prestamo == null) {
            LOG.severe("Préstamo no encontrado: " + prestamoId);
            throw new PrestamoNoEncontradoException(prestamoId);
        }

        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("Estado del préstamo: " + prestamo.toString()
                     + " con material " + prestamo.getMaterial().toString());
        }

        BigDecimal multa = calculadora.calcular(prestamo);
        LOG.info("Multa calculada: " + multa);

        try {
            prestamo.devolver(LocalDate.now(reloj));
            prestamos.save(prestamo);
        } catch (Exception e) {
            LOG.log(Level.SEVERE, "Error al guardar la devolución de " + prestamoId, e);
            throw new PersistenciaException("Error al devolver " + prestamoId, e);
        }

        LOG.info("Devolución completada");
        return new ResultadoDevolucion(prestamo, multa, false);
    }
}

package com.nexussoftware.bibliotech.red;

import com.fasterxml.jackson.annotation.*;
import java.math.BigDecimal;
import java.time.*;
import java.util.List;

/** (1) DTO de la API externa de disponibilidad. Refleja el JSON, no el dominio. */
@JsonIgnoreProperties(ignoreUnknown = true)          // (1) sobrevive a campos nuevos
public record RespuestaDisponibilidad(

        @JsonProperty("request_id")   String idPeticion,
        @JsonProperty("generated_at") Instant generadoEn,     // (4) instante absoluto
        @JsonProperty("items")        List<Item> items,
        @JsonProperty("warnings")     List<String> avisos) {

    @JsonIgnoreProperties(ignoreUnknown = true)
    public record Item(

            @JsonProperty("isbn_13") String isbn,

            // (2) la API v1 usa "book_title", la v2 usa "title"
            @JsonProperty("book_title")
            @JsonAlias({"title"})
            String titulo,

            @JsonProperty("stock") Stock stock,

            // (3) BigDecimal, NUNCA double para dinero (01-04, 11-03)
            @JsonProperty("unit_price") BigDecimal precioUnitario,

            @JsonProperty("currency") String moneda,

            // (4) fecha de negocio sin hora: LocalDate (10-05)
            @JsonProperty("last_updated") LocalDate ultimaActualizacion,

            @JsonProperty("tags") List<String> etiquetas,

            @JsonProperty("discontinued") boolean descatalogado) {

        @JsonIgnoreProperties(ignoreUnknown = true)
        public record Stock(
                @JsonProperty("available") int disponibles,
                @JsonProperty("reserved")  int reservados,
                @JsonProperty("warehouse") String almacen) { }

        // (5) traducción al dominio
        public DisponibilidadMaterial aDominio() {
            return new DisponibilidadMaterial(
                    isbn,
                    titulo,
                    stock == null ? 0 : stock.disponibles(),   // defensivo: el JSON puede omitirlo
                    precioUnitario,
                    ultimaActualizacion);
        }
    }

    /** (5) Todos los ítems, ya traducidos al dominio. */
    public List<DisponibilidadMaterial> aDominio() {
        return items == null ? List.of() : items.stream().map(Item::aDominio).toList();
    }
}

// (5) El record de DOMINIO: nombres en español, sin rastro de la API externa
public record DisponibilidadMaterial(
        String isbn,
        String titulo,
        int disponibles,
        BigDecimal precio,
        LocalDate actualizado) {

    public boolean hayExistencias() { return disponibles > 0; }
}

@Configuration
public class ConfiguracionJackson {

    @Bean
    public ObjectMapper objectMapper() {
        return JsonMapper.builder()

                // Soporte de java.time: sin esto, LocalDate e Instant fallan
                .addModule(new JavaTimeModule())

                // Fechas en ISO-8601, no como número de segundos.
                // Legible, interoperable y coherente con lo decidido en 10-05.
                .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)

                // Redundante con @JsonIgnoreProperties, pero protege
                // cualquier DTO donde alguien olvide la anotación.
                .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)

                // Los decimales del JSON se leen como BigDecimal, no como double.
                // Imprescindible para importes: evita 54.949999999999996.
                .enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)

                // No serializar campos null: respuestas más pequeñas.
                .serializationInclusion(JsonInclude.Include.NON_NULL)

                .build();
    }
}

class RespuestaDisponibilidadTest {

    private final ObjectMapper mapper = new ConfiguracionJackson().objectMapper();

    @Test
    @DisplayName("deserializa la respuesta y la traduce al dominio, ignorando campos desconocidos")
    void deserializaYTraduce() throws Exception {
        String json = """
                {
                  "request_id": "req-8821",
                  "generated_at": "2026-03-20T10:15:23Z",
                  "server_region": "eu-west-1",
                  "items": [
                    {
                      "isbn_13": "978-0000000001",
                      "book_title": "Java Efectivo",
                      "stock": { "available": 3, "reserved": 1, "warehouse": "MAD-01" },
                      "unit_price": 54.95,
                      "currency": "EUR",
                      "last_updated": "2026-03-19",
                      "tags": ["java", "best-practices"],
                      "discontinued": false,
                      "promo_code": "SPRING26"
                    }
                  ],
                  "warnings": []
                }
                """;   // bloque de texto de 10-06

        RespuestaDisponibilidad respuesta =
                mapper.readValue(json, RespuestaDisponibilidad.class);

        // Los campos desconocidos (server_region, promo_code) no rompen nada
        assertThat(respuesta.idPeticion()).isEqualTo("req-8821");
        assertThat(respuesta.generadoEn()).isEqualTo(Instant.parse("2026-03-20T10:15:23Z"));
        assertThat(respuesta.avisos()).isEmpty();

        assertThat(respuesta.aDominio()).singleElement().satisfies(d -> {
            assertThat(d.isbn()).isEqualTo("978-0000000001");
            assertThat(d.titulo()).isEqualTo("Java Efectivo");
            assertThat(d.disponibles()).isEqualTo(3);
            assertThat(d.precio()).isEqualByComparingTo("54.95");   // exacto, sin error
            assertThat(d.actualizado()).isEqualTo(LocalDate.of(2026, 3, 19));
            assertThat(d.hayExistencias()).isTrue();
        });
    }

    @Test
    @DisplayName("acepta también el nombre antiguo del campo título")
    void aceptaElAliasDeVersionAntigua() throws Exception {
        String jsonV2 = """
                {"items":[{"isbn_13":"978-0000000002","title":"Patrones de Diseño",
                           "stock":{"available":2},"unit_price":49.00,
                           "last_updated":"2026-03-18"}]}
                """;

        var respuesta = mapper.readValue(jsonV2, RespuestaDisponibilidad.class);

        assertThat(respuesta.aDominio()).singleElement()
                .extracting(DisponibilidadMaterial::titulo)
                .isEqualTo("Patrones de Diseño");
    }

    @Test
    @DisplayName("el precio se lee como BigDecimal exacto, no como double")
    void precioExacto() throws Exception {
        String json = """
                {"items":[{"isbn_13":"978-0000000003","book_title":"Refactorización",
                           "stock":{"available":1},"unit_price":0.1,
                           "last_updated":"2026-03-20"}]}
                """;

        var d = mapper.readValue(json, RespuestaDisponibilidad.class).aDominio().get(0);

        // Con double sería 0.1000000000000000055511151231257827
        assertThat(d.precio()).isEqualByComparingTo(new BigDecimal("0.1"));
        assertThat(d.precio().toPlainString()).isEqualTo("0.1");
    }
}

Material libro = Material.builder().isbn("978-0000000001").titulo("Java Efectivo").build();
Set<Material> seleccion = new HashSet<>();
seleccion.add(libro);                    // id = null -> hashCode H1 -> cubo A

repositorio.save(libro);                 // JPA asigna id = 42 -> hashCode H2

seleccion.contains(libro);               // busca en el cubo B -> FALSE

log.debug("Material: {}", material);

material.setId(99L);        // corrompe la identidad de la entidad
material.setVersion(0L);    // rompe el bloqueo optimista de 11-03

private int ejemplaresDisponibles = 1;
private List<Prestamo> prestamos = new ArrayList<>();
private Set<Categoria> categorias = new HashSet<>();

Material m = Material.builder().isbn("978-0000000001").build();
m.getEjemplaresDisponibles();   // 0, no 1
m.getPrestamos();               // null, no lista vacía -> NullPointerException

package com.nexussoftware.bibliotech.dominio;

import jakarta.persistence.*;
import java.util.*;
import lombok.*;

@Entity
@Table(name = "material")
@Getter                                                   // solo lectura pública
@Setter(AccessLevel.PROTECTED)                            // setters restringidos a JPA/subclases
@NoArgsConstructor(access = AccessLevel.PROTECTED)        // el que exige JPA (11-03)
@ToString(of = { "id", "isbn", "titulo", "ejemplaresDisponibles" })   // SOLO escalares
@EqualsAndHashCode(of = "isbn")                           // clave de negocio INMUTABLE
public class Material {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true, length = 20, updatable = false)
    private String isbn;                                  // updatable=false: nunca cambia

    @Column(nullable = false, length = 200)
    private String titulo;

    @Column(name = "ejemplares_disponibles", nullable = false)
    private int ejemplaresDisponibles;

    @OneToMany(mappedBy = "material", fetch = FetchType.LAZY)
    private List<Prestamo> prestamos = new ArrayList<>();

    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(name = "material_categoria",
               joinColumns = @JoinColumn(name = "material_id"),
               inverseJoinColumns = @JoinColumn(name = "categoria_id"))
    private Set<Categoria> categorias = new HashSet<>();

    @Version
    private Long version;

    /** Constructor público con validación: sustituye a @Builder y @AllArgsConstructor. */
    public Material(String isbn, String titulo, int ejemplaresDisponibles) {
        this.isbn = Objects.requireNonNull(isbn, "El ISBN es obligatorio");
        this.titulo = Objects.requireNonNull(titulo, "El título es obligatorio");
        if (ejemplaresDisponibles < 0) {
            throw new IllegalArgumentException("Los ejemplares no pueden ser negativos");
        }
        this.ejemplaresDisponibles = ejemplaresDisponibles;
    }

    // Métodos de DOMINIO con validación, en lugar de setters abiertos
    public void prestarUnEjemplar() {
        if (ejemplaresDisponibles <= 0) throw new SinEjemplaresException(isbn);
        ejemplaresDisponibles--;
    }

    public void devolverUnEjemplar() { ejemplaresDisponibles++; }

    /** Copia defensiva: nadie modifica la colección desde fuera (11-03 §13). */
    public List<Prestamo> getPrestamos() { return List.copyOf(prestamos); }
}

@Test
@DisplayName("un Material sigue siendo localizable en un HashSet tras recibir su id")
void identidadEstableTrasPersistir() {

    Material libro = new Material("978-0000000001", "Java Efectivo", 3);
    Set<Material> seleccion = new HashSet<>();
    seleccion.add(libro);

    // Simula lo que hace JPA al persistir: asignar el id generado
    ReflectionTestUtils.setField(libro, "id", 42L);

    // Con @Data esto FALLA: el hashCode cambió y el objeto está en otro cubo
    assertThat(seleccion).contains(libro);
    assertThat(seleccion.contains(libro)).isTrue();
}

@Test
@DisplayName("toString no accede a las relaciones perezosas")
void toStringSinRelaciones() {
    Material libro = new Material("978-0000000001", "Java Efectivo", 3);

    assertThat(libro.toString())
            .contains("978-0000000001")
            .contains("Java Efectivo")
            .doesNotContain("prestamos")      // habría disparado la consulta
            .doesNotContain("categorias");
}

@DataJpaTest
class MaterialToStringIT {

    @Autowired private TestEntityManager em;

    @Test
    @DisplayName("toString no provoca LazyInitializationException fuera de la sesión")
    void toStringSeguroFueraDeSesion() {
        Material libro = em.persistAndFlush(new Material("978-0000000001", "Java Efectivo", 3));
        em.clear();                                   // simula el cierre del contexto

        Material separado = em.getEntityManager()
                .getReference(Material.class, libro.getId());

        assertThatCode(separado::toString).doesNotThrowAnyException();
    }
}

config.stopBubbling = true

# @Data es la raíz de los dos incidentes: prohibido en todo el proyecto
lombok.data.flagUsage = error

# @Value es inmutable pero incompatible con JPA: aviso
lombok.value.flagUsage = warning

# @AllArgsConstructor permite construir entidades sin validación
lombok.allArgsConstructor.flagUsage = warning

# @SneakyThrows rompe el contrato de excepciones del módulo 6
lombok.sneakyThrows.flagUsage = error

# Los métodos generados no cuentan para la cobertura (12-05)
lombok.addLombokGeneratedAnnotation = true

package com.nexussoftware.bibliotech.servicio;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.UUID;
import org.slf4j.*;
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@RequiredArgsConstructor          // Lombok: inyección por constructor (11-02)
public class GestorDevoluciones {

    private static final Logger log = LoggerFactory.getLogger(GestorDevoluciones.class);
    // (o simplemente @Slf4j sobre la clase)

    private final PrestamoRepository prestamos;
    private final CalculadoraMultas calculadora;
    private final Clock reloj;

    @Transactional
    public ResultadoDevolucion devolver(Long prestamoId) {

        // (3) MDC: correlación de todas las líneas de esta devolución
        MDC.put("operacion", "devolucion");
        MDC.put("prestamoId", String.valueOf(prestamoId));
        MDC.put("idOperacion", UUID.randomUUID().toString());

        try {
            // (5) DEBUG, no INFO: el inicio de una operación no interesa en producción
            log.debug("Iniciando devolución");

            Prestamo prestamo = prestamos.findById(prestamoId)
                    .orElseThrow(() -> {
                        // (4) DEBUG, no ERROR: es un caso de negocio, no un fallo del sistema
                        log.debug("Préstamo no encontrado");
                        return new PrestamoNoEncontradoException(prestamoId);
                    });

            // (1)(2)(7) parametrizado, sin toString() de entidades, sin isLoggable
            log.debug("Préstamo localizado: isbn={}, vencimiento={}, estado={}",
                    prestamo.getMaterial().getIsbn(),     // solo campos ESCALARES
                    prestamo.getFechaVencimiento(),
                    prestamo.getEstado());

            BigDecimal multa = calculadora.calcular(prestamo);

            prestamo.devolver(LocalDate.now(reloj));
            prestamos.save(prestamo);
            // (3) sin catch: la excepción de persistencia sube y la registra quien la maneje

            // (5)(6) UNA línea INFO por operación, con TODO el contexto relevante
            log.info("Devolución completada: isbn={}, empleado={}, multa={} €, diasRetraso={}",
                    prestamo.getMaterial().getIsbn(),
                    prestamo.getEmpleado().getCorreo(),
                    multa,
                    prestamo.diasDeRetraso(LocalDate.now(reloj)));

            if (multa.compareTo(BigDecimal.ZERO) > 0) {
                log.warn("Devolución con multa: isbn={}, importe={} €",
                        prestamo.getMaterial().getIsbn(), multa);
            }

            return new ResultadoDevolucion(prestamo, multa, false);

        } finally {
            MDC.clear();   // (3) IMPRESCINDIBLE: el hilo vuelve al pool (10-07)
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <!-- ============ DESARROLLO: consola legible ============ -->
    <springProfile name="dev">

        <appender name="CONSOLA" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <pattern>%d{HH:mm:ss.SSS} %highlight(%-5level) [%thread] %cyan(%logger{30}) [%X{idOperacion:-sin-id}] - %msg%n</pattern>
                <charset>UTF-8</charset>
            </encoder>
        </appender>

        <logger name="com.nexussoftware.bibliotech" level="DEBUG"/>
        <logger name="org.hibernate.SQL" level="DEBUG"/>            <!-- SQL solo en dev -->
        <logger name="org.hibernate.orm.jdbc.bind" level="TRACE"/>  <!-- parámetros -->
        <logger name="org.springframework" level="INFO"/>

        <root level="INFO">
            <appender-ref ref="CONSOLA"/>
        </root>
    </springProfile>

    <!-- ============ PRODUCCIÓN: fichero rotado en JSON ============ -->
    <springProfile name="prod">

        <appender name="FICHERO_JSON" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>logs/bibliotech.json</file>

            <encoder class="net.logstash.logback.encoder.LogstashEncoder">
                <includeMdcKeyName>idOperacion</includeMdcKeyName>
                <includeMdcKeyName>prestamoId</includeMdcKeyName>
                <includeMdcKeyName>operacion</includeMdcKeyName>
                <customFields>{"aplicacion":"bibliotech","entorno":"prod"}</customFields>
            </encoder>

            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
                <fileNamePattern>logs/bibliotech-%d{yyyy-MM-dd}.%i.json.gz</fileNamePattern>
                <maxFileSize>100MB</maxFileSize>
                <maxHistory>30</maxHistory>
                <totalSizeCap>5GB</totalSizeCap>
            </rollingPolicy>
        </appender>

        <!-- Asíncrono: escribir en disco no bloquea el hilo de negocio -->
        <appender name="ASINCRONO" class="ch.qos.logback.classic.AsyncAppender">
            <appender-ref ref="FICHERO_JSON"/>
            <queueSize>1024</queueSize>
            <discardingThreshold>0</discardingThreshold>
        </appender>

        <logger name="com.nexussoftware.bibliotech" level="INFO"/>
        <logger name="org.hibernate.SQL" level="OFF"/>       <!-- NUNCA SQL en producción -->
        <logger name="org.springframework" level="WARN"/>

        <root level="INFO">
            <appender-ref ref="ASINCRONO"/>
        </root>
    </springProfile>

</configuration>