package java.io;

public interface Serializable {
    // Sin metodos. Ninguno.
}

package com.nexussoftware.bibliotech.dominio;

import java.io.Serializable;

public class Empleado implements Serializable {

    private static final long serialVersionUID = 1L;      // apartado 6

    private final String nombre;
    private final String identificador;
    private int prestamosActivos;

    // ... el resto igual que siempre
}

package com.nexussoftware.bibliotech.demo;

import java.io.*;

public class SerializacionBasica {

    public static void guardar(Empleado empleado, String ruta) throws IOException {
        try (ObjectOutputStream salida = new ObjectOutputStream(
                new BufferedOutputStream(new FileOutputStream(ruta)))) {

            salida.writeObject(empleado);        // escribe el objeto y todo su grafo
        }
    }

    public static Empleado cargar(String ruta) throws IOException, ClassNotFoundException {
        try (ObjectInputStream entrada = new ObjectInputStream(
                new BufferedInputStream(new FileInputStream(ruta)))) {

            // readObject devuelve Object: hay que convertir
            return (Empleado) entrada.readObject();
        }
    }

    public static void main(String[] args) throws Exception {
        Empleado marta = new Empleado("Marta Ruiz", "E-001");
        marta.registrarPrestamo();
        marta.registrarPrestamo();

        guardar(marta, "datos/marta.ser");

        Empleado recuperada = cargar("datos/marta.ser");
        System.out.println(recuperada.getNombre());              // Marta Ruiz
        System.out.println(recuperada.getPrestamosActivos());    // 2

        // Es OTRO objeto, con el MISMO estado
        System.out.println(marta == recuperada);                 // false
        System.out.println(marta.equals(recuperada));            // true, si equals esta bien (03-09)
    }
}

/** Varios objetos: se escriben y se leen EN EL MISMO ORDEN. */
public static void guardarVarios(List<Empleado> empleados, String ruta) throws IOException {
    try (ObjectOutputStream salida = new ObjectOutputStream(
            new BufferedOutputStream(new FileOutputStream(ruta)))) {

        salida.writeInt(empleados.size());          // primero, cuantos hay
        for (Empleado e : empleados) {
            salida.writeObject(e);
        }
    }
}

public static List<Empleado> cargarVarios(String ruta)
        throws IOException, ClassNotFoundException {

    List<Empleado> empleados = new ArrayList<>();
    try (ObjectInputStream entrada = new ObjectInputStream(
            new BufferedInputStream(new FileInputStream(ruta)))) {

        int cuantos = entrada.readInt();
        for (int i = 0; i < cuantos; i++) {
            empleados.add((Empleado) entrada.readObject());
        }
    }
    return empleados;
}

salida.writeObject(new ArrayList<>(empleados));      // un solo writeObject
// ...
List<Empleado> empleados = (List<Empleado>) entrada.readObject();

AC ED 00 05 73 72 00 2C 63 6F 6D 2E 6E 65 78 75  |....sr.,com.nexu|
73 73 6F 66 74 77 61 72 65 2E 62 69 62 6C 69 6F  |ssoftware.biblio|
74 65 63 68 2E 64 6F 6D 69 6E 69 6F 2E 45 6D 70  |tech.dominio.Emp|
6C 65 61 64 6F 00 00 00 00 00 00 00 01 02 00 03  |leado...........|

public class Prestamo implements Serializable {

    private static final long serialVersionUID = 1L;

    private final String referencia;
    private final Material material;
    private final int diaInicio;
    private int diaDevolucion = -1;

    // DERIVADO: se calcula a partir de los dias y la tarifa del material.
    // Guardarlo seria duplicar informacion, y peor: si la tarifa cambia,
    // el valor guardado quedaria obsoleto y contradiria al calculado.
    private transient double multaCalculada;
    private transient boolean multaEnCache = false;

    public double calcularMulta(int diaActual) {
        if (!multaEnCache) {
            multaCalculada = material.calcularMulta(diaActual - diaInicio);
            multaEnCache = true;
        }
        return multaCalculada;
    }
}

public class SesionUsuario implements Serializable {

    private static final long serialVersionUID = 1L;

    private final String identificador;

    // NUNCA en disco. Todo lo que 06-07 dijo sobre que no registrar se
    // aplica igual, o mas, a lo que se persiste: el fichero se queda.
    private transient char[] credencial;
    private transient String tokenDeSesion;
}

public class CacheFichas implements Serializable {

    private static final long serialVersionUID = 1L;

    // MAL: al deserializar sera null, no un HashMap vacio.
    // El inicializador NO se ejecuta.
    private transient Map<String, Ficha> cache = new HashMap<>();

    public void guardar(String clave, Ficha f) {
        cache.put(clave, f);        // NullPointerException tras deserializar
    }
}

import java.io.Serializable;
import java.util.logging.Logger;

public class GestorPrestamos implements Serializable {

    private static final long serialVersionUID = 1L;

    private final Catalogo catalogo;             // serializable
    private final RegistroPrestamos registro;    // serializable

    // PROBLEMA: Logger NO es Serializable.
    // Este unico campo hace que TODO el GestorPrestamos falle.
    private final Logger log = Logger.getLogger(GestorPrestamos.class.getName());
}

Exception in thread "main" java.io.NotSerializableException: java.util.logging.Logger
    at java.base/java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1197)
    at java.base/java.io.ObjectOutputStream.defaultWriteFields(...)
    at ...

public class GestorPrestamos implements Serializable {

    private static final long serialVersionUID = 1L;

    private final Catalogo catalogo;
    private final RegistroPrestamos registro;

    // transient: no se guarda. Y no hace falta, porque un Logger se
    // recupera con una llamada estatica en cualquier momento.
    private transient Logger log = Logger.getLogger(GestorPrestamos.class.getName());

    /**
     * Reinicializa lo transient tras la deserializacion (apartado 9).
     * Sin esto, 'log' seria null y el primer uso lanzaria NullPointerException.
     */
    private void readObject(java.io.ObjectInputStream entrada)
            throws java.io.IOException, ClassNotFoundException {

        entrada.defaultReadObject();
        log = Logger.getLogger(GestorPrestamos.class.getName());
    }
}

public class MaterialNoEncontradoException extends CatalogoException {
    private static final long serialVersionUID = 1L;
    // ...
}

public class Empleado implements Serializable {

    /**
     * Version de la forma serializada.
     *
     * SOLO se incrementa cuando se hace un cambio INCOMPATIBLE (apartado 8).
     * Los cambios compatibles (anadir campos, metodos, cambiar codigo)
     * mantienen el mismo valor.
     */
    private static final long serialVersionUID = 1L;

    // ...
}

private static final long serialVersionUID = 1L;

javac -Xlint:serial *.java

warning: [serial] serializable class Empleado has no definition of serialVersionUID

// VERSION 1 - se compila, se ejecuta y se guarda un fichero
public class Empleado implements Serializable {
    // SIN serialVersionUID declarado: se calcula automaticamente
    private final String nombre;
    private final String identificador;
    private int prestamosActivos;

    public Empleado(String nombre, String identificador) {
        this.nombre = nombre;
        this.identificador = identificador;
    }
    public String getNombre() { return nombre; }
}

Empleado marta = new Empleado("Marta Ruiz", "E-001");
guardar(marta, "datos/marta.ser");         // OK

// VERSION 2 - solo se anade un metodo
public class Empleado implements Serializable {
    private final String nombre;
    private final String identificador;
    private int prestamosActivos;

    public Empleado(String nombre, String identificador) {
        this.nombre = nombre;
        this.identificador = identificador;
    }
    public String getNombre() { return nombre; }

    /** Metodo NUEVO. No toca el estado. */
    public String getIniciales() {
        String[] partes = nombre.split(" ");
        return "" + partes[0].charAt(0) + partes[1].charAt(0);
    }
}

Exception in thread "main" java.io.InvalidClassException:
    com.nexussoftware.bibliotech.dominio.Empleado;
    local class incompatible:
    stream classdesc serialVersionUID = -4738291056473829104,
    local class serialVersionUID = 8273645019283746152

private void writeObject(ObjectOutputStream salida) throws IOException;
private void readObject(ObjectInputStream entrada) throws IOException, ClassNotFoundException;

package com.nexussoftware.bibliotech.servicio;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;

import com.nexussoftware.bibliotech.dominio.Ficha;

/**
 * Cache de fichas con serializacion personalizada.
 *
 * La cache NO se guarda (es derivada), pero hay que reconstruirla vacia al
 * cargar: si no, seria null y el primer uso lanzaria NullPointerException.
 */
public class CacheFichas implements Serializable {

    private static final long serialVersionUID = 1L;

    /** static: no se serializa. La convencion correcta para un Logger. */
    private static final Logger LOG = Logger.getLogger(CacheFichas.class.getName());

    private final String nombre;
    private int capacidadMaxima;

    /** transient: al deserializar sera null si no lo arreglamos. */
    private transient Map<String, Ficha> cache = new HashMap<>();
    private transient int aciertos = 0;
    private transient int fallos = 0;

    public CacheFichas(String nombre, int capacidadMaxima) {
        this.nombre = java.util.Objects.requireNonNull(nombre);
        if (capacidadMaxima < 1) {
            throw new IllegalArgumentException(
                    "La capacidad debe ser al menos 1, y era: " + capacidadMaxima);
        }
        this.capacidadMaxima = capacidadMaxima;
    }

    /**
     * Serializacion personalizada.
     *
     * USO 1: registrar la operacion.
     * USO 2: escribir datos adicionales tras los campos por defecto.
     */
    private void writeObject(ObjectOutputStream salida) throws IOException {
        LOG.fine(() -> "Serializando cache '" + nombre + "' con "
                + cache.size() + " entradas (que NO se guardan)");

        salida.defaultWriteObject();          // primero, los campos normales

        // Se pueden escribir datos extra. Se leeran en el MISMO orden.
        salida.writeInt(cache.size());        // solo informativo
    }

    /**
     * Deserializacion personalizada.
     *
     * USO 3: reinicializar los campos transient.
     * USO 4: VALIDAR el estado leido.
     */
    private void readObject(ObjectInputStream entrada)
            throws IOException, ClassNotFoundException {

        entrada.defaultReadObject();          // primero, los campos normales

        int tamanoAnterior = entrada.readInt();   // el extra, en el mismo orden

        // USO 3: reinicializar. Sin esto, cache seria null.
        this.cache = new HashMap<>();
        this.aciertos = 0;
        this.fallos = 0;

        // USO 4: VALIDAR. La deserializacion NO llama al constructor, asi que
        // sus comprobaciones no se han ejecutado. Un fichero manipulado o de
        // una version antigua puede traer valores imposibles.
        if (capacidadMaxima < 1) {
            LOG.warning(() -> "Capacidad invalida al deserializar ("
                    + capacidadMaxima + "); se corrige a 100");
            this.capacidadMaxima = 100;
        }
        if (nombre == null) {
            throw new java.io.InvalidObjectException(
                    "Cache deserializada sin nombre: fichero corrupto o manipulado");
        }

        LOG.fine(() -> "Cache '" + nombre + "' restaurada vacia (tenia "
                + tamanoAnterior + " entradas)");
    }

    public java.util.Optional<Ficha> buscar(String clave) {
        Ficha f = cache.get(clave);
        if (f != null) { aciertos++; } else { fallos++; }
        return java.util.Optional.ofNullable(f);
    }

    public void guardar(String clave, Ficha ficha) {
        if (cache.size() >= capacidadMaxima) {
            cache.clear();                    // politica simple de desalojo
        }
        cache.put(clave, ficha);
    }

    public int getAciertos() { return aciertos; }
    public int getFallos()   { return fallos; }
}

/** Preserva el patron singleton al deserializar. */
private Object readResolve() {
    return INSTANCIA;      // se devuelve la instancia unica, no la deserializada
}

public interface Externalizable extends Serializable {
    void writeExternal(ObjectOutput salida) throws IOException;
    void readExternal(ObjectInput entrada) throws IOException, ClassNotFoundException;
}

public class Ubicacion implements Externalizable {

    private String sala;
    private int estanteria;
    private int balda;

    /** OBLIGATORIO y PUBLICO: Externalizable lo llama al deserializar. */
    public Ubicacion() { }

    public Ubicacion(String sala, int estanteria, int balda) {
        this.sala = sala;
        this.estanteria = estanteria;
        this.balda = balda;
    }

    @Override
    public void writeExternal(ObjectOutput salida) throws IOException {
        salida.writeUTF(sala);
        salida.writeInt(estanteria);
        salida.writeInt(balda);
    }

    @Override
    public void readExternal(ObjectInput entrada) throws IOException {
        sala = entrada.readUTF();          // el MISMO orden
        estanteria = entrada.readInt();
        balda = entrada.readInt();
    }
}

/** Superclase NO serializable. */
public abstract class ElementoInventario {

    private final String codigoInterno;
    private int revisiones;

    /**
     * OBLIGATORIO para que las subclases serializables funcionen.
     * Sin el: InvalidClassException "no valid constructor".
     */
    protected ElementoInventario() {
        this.codigoInterno = "SIN-CODIGO";     // valor por defecto
        this.revisiones = 0;
    }

    protected ElementoInventario(String codigoInterno) {
        this.codigoInterno = codigoInterno;
        this.revisiones = 0;
    }

    public String getCodigoInterno() { return codigoInterno; }
}

/** Subclase SI serializable. */
public class Material extends ElementoInventario implements Serializable {

    private static final long serialVersionUID = 1L;

    private final String titulo;
    private final String referencia;
    private boolean disponible;

    // ...
}

java.io.InvalidClassException: com.nexussoftware.bibliotech.dominio.Material;
    no valid constructor

// Este codigo YA ES VULNERABLE si 'entrada' viene de fuera.
// La comprobacion llega TARDE: el dano se produjo dentro de readObject().
Object o = entrada.readObject();
if (o instanceof Prestamo p) {          // <-- demasiado tarde
    procesar(p);
}

package com.nexussoftware.bibliotech.infraestructura;

import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;

/**
 * Filtros de deserializacion para BiblioTech.
 *
 * ADVERTENCIA: un filtro REDUCE el riesgo, no lo elimina. La unica defensa
 * completa es no deserializar datos no confiables (apartado 12).
 */
public final class FiltroDeserializacion {

    private FiltroDeserializacion() { }

    /**
     * Filtro por lista blanca: solo se permiten las clases de BiblioTech
     * y un conjunto minimo del JDK. Todo lo demas se RECHAZA.
     *
     * La lista blanca es la unica forma correcta: una lista negra siempre
     * se queda corta, porque no puedes enumerar todo lo peligroso.
     */
    public static ObjectInputFilter deBiblioTech() {
        String patron = String.join(";",
                "com.nexussoftware.bibliotech.**",   // nuestras clases
                "java.util.ArrayList",
                "java.util.LinkedList",
                "java.util.HashMap",
                "java.util.HashSet",
                "java.lang.String",
                "java.lang.Number",
                "java.lang.Integer",
                "java.lang.Double",
                "java.lang.Boolean",
                "java.lang.Enum",
                "maxdepth=20",           // profundidad maxima del grafo
                "maxrefs=10000",         // referencias maximas
                "maxbytes=10485760",     // 10 MB
                "maxarray=100000",       // elementos maximos de un array
                "!*");                   // RECHAZAR TODO LO DEMAS

        return ObjectInputFilter.Config.createFilter(patron);
    }

    /** Aplica el filtro a un flujo concreto. */
    public static void aplicarA(ObjectInputStream entrada) {
        entrada.setObjectInputFilter(deBiblioTech());
    }
}

try (ObjectInputStream entrada = new ObjectInputStream(
        new BufferedInputStream(new FileInputStream(ruta)))) {

    // ANTES de cualquier readObject
    FiltroDeserializacion.aplicarA(entrada);

    SesionBiblioteca sesion = (SesionBiblioteca) entrada.readObject();
}

java.io.InvalidClassException: filter status: REJECTED

java -Djdk.serialFilter='com.nexussoftware.bibliotech.**;java.util.*;!*' BiblioTechApp

package com.nexussoftware.bibliotech.servicio;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.nexussoftware.bibliotech.infraestructura.FiltroDeserializacion;

/**
 * Guarda y restaura el estado de una sesion de trabajo de BiblioTech.
 *
 * POR QUE AQUI SI ES ADMISIBLE LA SERIALIZACION NATIVA:
 *   - El fichero lo escribe y lo lee la MISMA aplicacion.
 *   - Vive en el directorio de datos local, no viaja por red ni lo sube nadie.
 *   - Su contenido se puede REGENERAR: si se corrompe, se borra y se empieza
 *     una sesion nueva. No es la fuente de verdad; el catalogo en CSV lo es.
 *
 * POR QUE EL CATALOGO NO USA ESTO: el catalogo es el dato de valor, debe ser
 * legible, versionable e importable desde una hoja de calculo. Eso es 07-07.
 *
 * Aun asi se aplica un FILTRO de deserializacion: defensa en profundidad.
 */
public class GestorSesion {

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

    private static final String EXTENSION = ".sesion";

    private final File directorio;

    public GestorSesion(String directorioDatos) {
        this.directorio = new File(
                Objects.requireNonNull(directorioDatos, "El directorio no puede ser nulo"));
        if (!directorio.exists() && !directorio.mkdirs()) {
            LOG.warning("No se pudo crear " + directorio.getAbsolutePath());
        }
    }

    // ------------------------- EL ESTADO -------------------------

    /**
     * Instantanea serializable del estado de una sesion.
     *
     * Es una clase APARTE de SesionBiblioteca a proposito: la sesion
     * gestiona recursos (bloqueos, logger) que no deben serializarse.
     * Esta clase solo contiene DATOS.
     */
    public static class EstadoSesion implements Serializable {

        /**
         * DECLARADO desde el primer dia. Sin el, anadir un metodo privado
         * dentro de seis meses dejaria ilegibles todas las sesiones guardadas
         * (apartado 7).
         */
        private static final long serialVersionUID = 1L;

        private final String idEmpleado;
        private final int diaApertura;
        private final List<String> operaciones;
        private final int prestamosRealizados;
        private final int devolucionesRealizadas;
        private final double multasCobradas;

        /** Derivado: se recalcula. No tiene sentido guardarlo. */
        private transient String resumenFormateado;

        public EstadoSesion(String idEmpleado, int diaApertura, List<String> operaciones,
                            int prestamosRealizados, int devolucionesRealizadas,
                            double multasCobradas) {

            this.idEmpleado = Objects.requireNonNull(idEmpleado, "El empleado es obligatorio");
            if (diaApertura < 1) {
                throw new IllegalArgumentException("Dia invalido: " + diaApertura);
            }
            if (multasCobradas < 0) {
                throw new IllegalArgumentException("Multas negativas: " + multasCobradas);
            }
            this.diaApertura = diaApertura;
            // ArrayList explicito: es serializable y su forma es estable
            this.operaciones = new ArrayList<>(operaciones);
            this.prestamosRealizados = prestamosRealizados;
            this.devolucionesRealizadas = devolucionesRealizadas;
            this.multasCobradas = multasCobradas;
        }

        /**
         * VALIDACION al deserializar.
         *
         * Imprescindible: la deserializacion NO llama al constructor, asi que
         * las comprobaciones de arriba NO se han ejecutado. Un fichero
         * corrupto o manipulado podria traer un dia negativo o multas
         * imposibles, y el resto del sistema los daria por buenos.
         */
        private void readObject(ObjectInputStream entrada)
                throws IOException, ClassNotFoundException {

            entrada.defaultReadObject();

            if (idEmpleado == null || idEmpleado.isBlank()) {
                throw new InvalidObjectException(
                        "Sesion sin empleado: fichero corrupto o manipulado");
            }
            if (diaApertura < 1) {
                throw new InvalidObjectException(
                        "Dia de apertura invalido: " + diaApertura);
            }
            if (multasCobradas < 0) {
                throw new InvalidObjectException(
                        "Multas negativas: " + multasCobradas);
            }
            if (operaciones == null) {
                throw new InvalidObjectException("Lista de operaciones nula");
            }
            // El transient se recalcula bajo demanda: no hay que tocarlo aqui
        }

        public String getIdEmpleado()          { return idEmpleado; }
        public int getDiaApertura()            { return diaApertura; }
        public List<String> getOperaciones()   { return List.copyOf(operaciones); }
        public int getPrestamosRealizados()    { return prestamosRealizados; }
        public int getDevolucionesRealizadas() { return devolucionesRealizadas; }
        public double getMultasCobradas()      { return multasCobradas; }

        /** Campo derivado: se calcula la primera vez y se cachea. */
        public String getResumen() {
            if (resumenFormateado == null) {
                resumenFormateado = String.format(
                        "Sesion de %s (dia %d): %d prestamos, %d devoluciones, %.2f EUR",
                        idEmpleado, diaApertura, prestamosRealizados,
                        devolucionesRealizadas, multasCobradas);
            }
            return resumenFormateado;
        }
    }

    // ------------------------- GUARDAR -------------------------

    /**
     * Guarda el estado de forma ATOMICA (07-02): temporal y renombrado.
     *
     * Una sesion guardada a medias seria peor que ninguna: al restaurarla
     * daria StreamCorruptedException o, peor, un objeto incompleto.
     */
    public void guardar(EstadoSesion estado) throws IOException {
        Objects.requireNonNull(estado, "El estado no puede ser nulo");

        File destino = new File(directorio, estado.getIdEmpleado() + EXTENSION);
        File temporal = new File(destino.getAbsolutePath() + ".tmp");

        boolean completado = false;
        try {
            try (ObjectOutputStream salida = new ObjectOutputStream(
                    new BufferedOutputStream(new FileOutputStream(temporal)))) {

                salida.writeObject(estado);
            }   // close() -> flush garantizado

            if (destino.exists() && !destino.delete()) {
                throw new IOException("No se pudo sustituir " + destino.getName());
            }
            if (!temporal.renameTo(destino)) {
                throw new IOException("No se pudo renombrar " + temporal.getName());
            }
            completado = true;

            LOG.info(() -> String.format("Sesion de %s guardada en %s (%d bytes)",
                    estado.getIdEmpleado(), destino.getName(), destino.length()));

        } finally {
            if (!completado && temporal.exists() && !temporal.delete()) {
                LOG.warning(() -> "Temporal sin borrar: " + temporal.getAbsolutePath());
            }
        }
    }

    // ------------------------- RESTAURAR -------------------------

    /**
     * Restaura la sesion de un empleado.
     *
     * DEGRADACION ELEGANTE (06-07): si no hay sesion guardada, o si esta
     * corrupta, o si la clase cambio, se devuelve vacio y se empieza de
     * cero. Perder una sesion no es un fallo grave: los datos de valor
     * estan en el catalogo.
     *
     * @return Optional vacio si no se pudo restaurar
     */
    public java.util.Optional<EstadoSesion> restaurar(String idEmpleado) {
        File fichero = new File(directorio, idEmpleado + EXTENSION);

        if (!fichero.exists()) {
            LOG.fine(() -> "No hay sesion guardada para " + idEmpleado);
            return java.util.Optional.empty();
        }

        try (ObjectInputStream entrada = new ObjectInputStream(
                new BufferedInputStream(new FileInputStream(fichero)))) {

            // FILTRO antes de leer nada. Defensa en profundidad (apartado 13).
            FiltroDeserializacion.aplicarA(entrada);

            EstadoSesion estado = (EstadoSesion) entrada.readObject();

            LOG.info(() -> "Sesion restaurada: " + estado.getResumen());
            return java.util.Optional.of(estado);

        } catch (InvalidClassException e) {
            // La clase cambio de forma incompatible (apartado 8).
            LOG.log(Level.WARNING, "La sesion de " + idEmpleado
                    + " se guardo con otra version de la aplicacion y no se puede leer", e);
            descartar(fichero);
            return java.util.Optional.empty();

        } catch (InvalidObjectException e) {
            // Nuestro readObject rechazo el contenido: corrupto o manipulado.
            LOG.log(Level.SEVERE, "Sesion de " + idEmpleado + " rechazada por validacion", e);
            descartar(fichero);
            return java.util.Optional.empty();

        } catch (StreamCorruptedException | EOFException e) {
            // Fichero truncado: se corto una escritura. La escritura atomica
            // de guardar() lo evita, pero un fallo del disco no.
            LOG.log(Level.WARNING, "Sesion de " + idEmpleado + " corrupta", e);
            descartar(fichero);
            return java.util.Optional.empty();

        } catch (ClassNotFoundException e) {
            // No extiende IOException: necesita su propio catch (apartado 3)
            LOG.log(Level.SEVERE, "Clase no encontrada al restaurar la sesion de "
                    + idEmpleado, e);
            return java.util.Optional.empty();

        } catch (IOException e) {
            LOG.log(Level.SEVERE, "Fallo de E/S restaurando la sesion de " + idEmpleado, e);
            return java.util.Optional.empty();
        }
    }

    /** Aparta un fichero ilegible en vez de borrarlo: puede hacer falta para diagnosticar. */
    private void descartar(File fichero) {
        File apartado = new File(fichero.getAbsolutePath() + ".invalido");
        if (apartado.exists()) {
            apartado.delete();
        }
        if (fichero.renameTo(apartado)) {
            LOG.info(() -> "Sesion ilegible apartada como " + apartado.getName());
        }
    }
}

public class DemoSesion {

    public static void main(String[] args) throws IOException {
        GestorSesion gestor = new GestorSesion("datos/sesiones");

        // --- Al arrancar: intentar restaurar ---
        gestor.restaurar("E-001").ifPresentOrElse(
                estado -> System.out.println("Continuando: " + estado.getResumen()),
                ()     -> System.out.println("Sesion nueva para E-001"));

        // --- Trabajo del turno ---
        List<String> operaciones = new ArrayList<>();
        operaciones.add("PRESTAMO PR-0001");
        operaciones.add("PRESTAMO PR-0002");
        operaciones.add("DEVOLUCION PR-0001 (multa 1,75)");

        // --- Al salir: guardar ---
        gestor.guardar(new GestorSesion.EstadoSesion(
                "E-001", 15, operaciones, 2, 1, 1.75));

        System.out.println("Sesion guardada. Vuelve a ejecutar para ver la restauracion.");
    }
}

Sesion nueva para E-001
Sesion guardada. Vuelve a ejecutar para ver la restauracion.

Continuando: Sesion de E-001 (dia 15): 2 prestamos, 1 devoluciones, 1,75 EUR
Sesion guardada. Vuelve a ejecutar para ver la restauracion.

package com.nexussoftware.bibliotech.demo;

import java.io.*;

/**
 * Laboratorio del serialVersionUID.
 *
 * COMO REPRODUCIR EL EXPERIMENTO PRINCIPAL:
 *
 *   1. Compilar y ejecutar con el metodo getEtiqueta() COMENTADO en DatoV1.
 *      Se genera datos/v1.ser
 *
 *   2. DESCOMENTAR getEtiqueta() (un metodo PRIVADO, que no toca el estado).
 *
 *   3. Recompilar y volver a ejecutar.
 *
 *   RESULTADO: al leer datos/v1.ser se obtiene
 *
 *     java.io.InvalidClassException: ...DatoV1; local class incompatible:
 *       stream classdesc serialVersionUID = -4738291056473829104,
 *       local class serialVersionUID = 8273645019283746152
 *
 *   El fichero queda ILEGIBLE PARA SIEMPRE por haber anadido un metodo
 *   privado que no afecta al estado en absoluto.
 */
public class LaboratorioCompatibilidad {

    // ---------------- SIN serialVersionUID: fragil ----------------

    static class DatoV1 implements Serializable {
        // SIN serialVersionUID: se calcula automaticamente a partir de
        // nombre, campos, METODOS (incluidos los privados), constructores...
        private final String referencia;
        private final String titulo;
        private final int anio;

        DatoV1(String referencia, String titulo, int anio) {
            this.referencia = referencia;
            this.titulo = titulo;
            this.anio = anio;
        }

        // PASO 2 DEL EXPERIMENTO: descomentar esto y recompilar.
        // private String getEtiqueta() { return referencia + " - " + titulo; }

        @Override
        public String toString() {
            return String.format("DatoV1[%s, %s, %d]", referencia, titulo, anio);
        }
    }

    // ---------------- CON serialVersionUID: estable ----------------

    /** Version B: tres campos, UID declarado. */
    static class DatoV2 implements Serializable {
        private static final long serialVersionUID = 1L;

        private final String referencia;
        private final String titulo;
        private final int anio;

        // CAMPO ANADIDO en la version 2. Compatible: los ficheros escritos
        // sin el se leen igual, y este campo toma su valor por defecto.
        private final String autor;

        DatoV2(String referencia, String titulo, int anio, String autor) {
            this.referencia = referencia;
            this.titulo = titulo;
            this.anio = anio;
            this.autor = autor;
        }

        @Override
        public String toString() {
            return String.format("DatoV2[%s, %s, %d, autor=%s]",
                    referencia, titulo, anio,
                    autor == null ? "(null: fichero antiguo)" : autor);
        }
    }

    // ---------------- Utilidades ----------------

    static void guardar(Object o, String ruta) throws IOException {
        try (ObjectOutputStream salida = new ObjectOutputStream(
                new BufferedOutputStream(new FileOutputStream(ruta)))) {
            salida.writeObject(o);
        }
    }

    static Object cargar(String ruta) throws IOException, ClassNotFoundException {
        try (ObjectInputStream entrada = new ObjectInputStream(
                new BufferedInputStream(new FileInputStream(ruta)))) {
            return entrada.readObject();
        }
    }

    /** Muestra el UID que el mecanismo asigna a una clase, declarado o calculado. */
    static long uidDe(Class<?> clase) {
        ObjectStreamClass osc = ObjectStreamClass.lookup(clase);
        return (osc == null) ? 0L : osc.getSerialVersionUID();
    }

    public static void main(String[] args) throws Exception {
        new File("datos").mkdirs();

        System.out.println("=== UID DE CADA CLASE ===");
        System.out.printf("  DatoV1 (sin declarar): %d%n", uidDe(DatoV1.class));
        System.out.printf("  DatoV2 (declarado)   : %d%n", uidDe(DatoV2.class));
        System.out.println("  El primero cambia al tocar la clase; el segundo, nunca.");
        System.out.println();

        // --- Experimento 1: sin UID declarado ---
        System.out.println("=== SIN serialVersionUID ===");
        File v1 = new File("datos/v1.ser");

        if (!v1.exists()) {
            guardar(new DatoV1("978-0000000001", "Java Efectivo", 2018), v1.getPath());
            System.out.println("  Fichero creado. AHORA: descomenta getEtiqueta(),");
            System.out.println("  recompila y vuelve a ejecutar.");
        } else {
            try {
                System.out.println("  Leido: " + cargar(v1.getPath()));
                System.out.println("  (la clase no ha cambiado desde que se guardo)");
            } catch (InvalidClassException e) {
                System.out.println("  INCOMPATIBLE, como se esperaba:");
                System.out.println("  " + e.getMessage());
                System.out.println("  Causa: se anadio un metodo. El fichero es ilegible.");
            }
        }

        // --- Experimento 2: con UID declarado y campo anadido ---
        System.out.println();
        System.out.println("=== CON serialVersionUID ===");

        File v2 = new File("datos/v2.ser");
        guardar(new DatoV2("978-0000000002", "Patrones de Diseno", 1994, "Gamma"),
                v2.getPath());
        System.out.println("  Guardado y leido: " + cargar(v2.getPath()));

        System.out.println();
        System.out.println("=== CAMBIOS COMPATIBLES (con el UID declarado) ===");
        System.out.println("  COMPATIBLES:");
        System.out.println("    - Anadir un campo        -> vale null / 0 / false");
        System.out.println("    - Eliminar un campo      -> el valor del fichero se descarta");
        System.out.println("    - Anadir o quitar metodos-> ningun efecto");
        System.out.println("    - Cambiar el cuerpo      -> ningun efecto");
        System.out.println("    - normal <-> transient   -> como anadir o quitar campo");
        System.out.println("  INCOMPATIBLES:");
        System.out.println("    - Cambiar el TIPO de un campo -> InvalidClassException");
        System.out.println("    - RENOMBRAR un campo          -> se PIERDE el dato, sin error");
        System.out.println("    - Renombrar o mover la clase  -> ClassNotFoundException");
        System.out.println("    - Cambiar la herencia         -> InvalidClassException");
    }
}

package com.nexussoftware.bibliotech.util;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

/**
 * Copia profunda mediante serializacion en memoria.
 *
 * Serializa a un array de bytes y deserializa desde el: el resultado es un
 * grafo completamente nuevo, sin ninguna referencia compartida con el
 * original. Sin tocar el disco: ByteArrayOutputStream / ByteArrayInputStream
 * (07-03).
 *
 * TRES LIMITACIONES REALES:
 *
 *   1. TODO el grafo debe ser Serializable. Un solo campo no serializable a
 *      cualquier profundidad hace fallar la copia entera (NotSerializableException).
 *
 *   2. ES LENTA. Serializar y deserializar implica reflexion, construccion
 *      de metadatos y copia de bytes. Un metodo de copia escrito a mano es
 *      entre diez y cien veces mas rapido.
 *
 *   3. LOS CAMPOS transient NO SE COPIAN. Quedan a null o 0 en la copia,
 *      que es correcto para una cache pero un error silencioso si el campo
 *      se marco transient por otro motivo.
 *
 *   Y una cuarta que conviene tener presente: si el objeto viniera de una
 *   fuente no confiable, esta tecnica hereda TODOS los riesgos del apartado
 *   12. Usala solo con objetos que ya tienes en memoria y controlas.
 */
public final class CopiaProfunda {

    private CopiaProfunda() { }

    /**
     * Copia profunda de un objeto serializable.
     *
     * Devuelve Object: convertir es cosa de quien llama. (Con genericos
     * quedaria mejor, pero eso es 10-01.)
     */
    public static Object copiar(Serializable original) throws IOException {
        if (original == null) {
            return null;
        }

        ByteArrayOutputStream memoria = new ByteArrayOutputStream();

        try (ObjectOutputStream salida = new ObjectOutputStream(memoria)) {
            salida.writeObject(original);
        }
        // ByteArrayOutputStream no necesita cerrarse: su close() no hace nada,
        // y cerrarlo antes de toByteArray() seria un error conceptual (07-03).

        try (ObjectInputStream entrada = new ObjectInputStream(
                new ByteArrayInputStream(memoria.toByteArray()))) {

            return entrada.readObject();

        } catch (ClassNotFoundException e) {
            // Imposible en la practica: la clase esta cargada, acabamos de
            // serializarla. Se traduce a IOException para no obligar a
            // quien llama a capturar algo que no puede pasar (06-03).
            throw new IOException("Fallo imposible al copiar: clase no encontrada", e);
        }
    }

    // ------------------------- DEMOSTRACION -------------------------

    /** Objeto de prueba con una lista mutable dentro. */
    static class CarritoPrestamos implements Serializable {
        private static final long serialVersionUID = 1L;

        private final String idEmpleado;
        private final List<String> referencias;
        private double totalEstimado;

        /** transient: NO se copiara. Queda a null en la copia. */
        private transient String notaInterna;

        CarritoPrestamos(String idEmpleado) {
            this.idEmpleado = idEmpleado;
            this.referencias = new ArrayList<>();
            this.notaInterna = "nota de trabajo";
        }

        void anadir(String referencia, double coste) {
            referencias.add(referencia);
            totalEstimado += coste;
        }

        List<String> getReferencias() { return referencias; }   // referencia mutable
        String getNotaInterna()       { return notaInterna; }

        @Override
        public String toString() {
            return String.format("Carrito[%s, %s, %.2f, nota=%s]",
                    idEmpleado, referencias, totalEstimado,
                    notaInterna == null ? "(null)" : notaInterna);
        }
    }

    /** Copia manual, escrita a mano, para comparar rendimiento. */
    static CarritoPrestamos copiarAMano(CarritoPrestamos original) {
        CarritoPrestamos copia = new CarritoPrestamos(original.idEmpleado);
        copia.referencias.addAll(original.referencias);      // nueva lista
        copia.totalEstimado = original.totalEstimado;
        copia.notaInterna = original.notaInterna;            // esta SI se copia
        return copia;
    }

    public static void main(String[] args) throws IOException {
        CarritoPrestamos original = new CarritoPrestamos("E-001");
        original.anadir("978-0000000001", 0.25);
        original.anadir("978-0000000002", 0.25);

        System.out.println("=== COPIA SUPERFICIAL (asignacion de referencia) ===");
        CarritoPrestamos superficial = original;
        superficial.getReferencias().add("978-0000000003");
        System.out.println("  Original: " + original.getReferencias());
        System.out.println("  'Copia' : " + superficial.getReferencias());
        System.out.println("  Son el MISMO objeto: " + (original == superficial));

        System.out.println();
        System.out.println("=== COPIA PROFUNDA (serializacion) ===");
        CarritoPrestamos profunda = (CarritoPrestamos) copiar(original);
        profunda.getReferencias().add("978-0000000004");

        System.out.println("  Original: " + original.getReferencias());
        System.out.println("  Copia   : " + profunda.getReferencias());
        System.out.println("  Objetos distintos      : " + (original != profunda));
        System.out.println("  Listas distintas       : "
                + (original.getReferencias() != profunda.getReferencias()));
        System.out.println("  Nota (transient) copiada: " + profunda.getNotaInterna());

        System.out.println();
        System.out.println("=== RENDIMIENTO (10 000 copias) ===");

        long inicio = System.nanoTime();
        for (int i = 0; i < 10_000; i++) {
            copiar(original);
        }
        long msSerializacion = (System.nanoTime() - inicio) / 1_000_000;

        inicio = System.nanoTime();
        for (int i = 0; i < 10_000; i++) {
            copiarAMano(original);
        }
        long msManual = (System.nanoTime() - inicio) / 1_000_000;

        System.out.printf("  Por serializacion: %5d ms%n", msSerializacion);
        System.out.printf("  A mano           : %5d ms%n", msManual);
        System.out.printf("  Factor           : %.1fx mas lenta%n",
                (double) msSerializacion / Math.max(1, msManual));
    }
}

=== COPIA SUPERFICIAL (asignacion de referencia) ===
  Original: [978-0000000001, 978-0000000002, 978-0000000003]
  'Copia' : [978-0000000001, 978-0000000002, 978-0000000003]
  Son el MISMO objeto: true

=== COPIA PROFUNDA (serializacion) ===
  Original: [978-0000000001, 978-0000000002, 978-0000000003]
  Copia   : [978-0000000001, 978-0000000002, 978-0000000003, 978-0000000004]
  Objetos distintos      : true
  Listas distintas       : true
  Nota (transient) copiada: null

=== RENDIMIENTO (10 000 copias) ===
  Por serializacion:   412 ms
  A mano           :     4 ms
  Factor           : 103.0x mas lenta

package com.nexussoftware.bibliotech.servicio;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.nexussoftware.bibliotech.infraestructura.FiltroDeserializacion;

/**
 * Gestor de sesiones con soporte de DOS versiones del estado guardado.
 *
 * La version 2 anade el campo 'materialesConsultados' MANTENIENDO el mismo
 * serialVersionUID, porque anadir un campo es un cambio COMPATIBLE: los
 * ficheros de la version 1 se siguen leyendo y el campo nuevo llega a 0.
 *
 * El truco esta en readObject: distinguir "de verdad se consultaron 0" de
 * "este fichero es antiguo y no lo sabe" es imposible con el valor por
 * defecto, asi que se usa un CENTINELA explicito.
 */
public class GestorSesionVersionado {

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

    private static final String EXTENSION = ".sesion";
    private static final String EXTENSION_INVALIDA = ".sesion.invalido";

    private final File directorio;

    public GestorSesionVersionado(String directorioDatos) {
        this.directorio = new File(Objects.requireNonNull(directorioDatos));
        if (!directorio.exists() && !directorio.mkdirs()) {
            LOG.warning("No se pudo crear " + directorio.getAbsolutePath());
        }
    }

    // ------------------------- EL ESTADO, VERSION 2 -------------------------

    public static class EstadoSesion implements Serializable {

        /** MISMO valor que en la version 1: el cambio es compatible. */
        private static final long serialVersionUID = 1L;

        /** Marca "no informado", para distinguirlo de un 0 real. */
        private static final int NO_INFORMADO = -1;

        private final String idEmpleado;
        private final int diaApertura;
        private final List<String> operaciones;
        private final int prestamosRealizados;
        private final int devolucionesRealizadas;
        private final double multasCobradas;

        /**
         * CAMPO ANADIDO EN LA VERSION 2.
         *
         * No es final: readObject necesita poder corregirlo cuando el
         * fichero viene de la version 1.
         */
        private int materialesConsultados;

        /** Version del formato con la que se creo. transient: se deduce. */
        private transient int versionDetectada = 2;

        public EstadoSesion(String idEmpleado, int diaApertura, List<String> operaciones,
                            int prestamosRealizados, int devolucionesRealizadas,
                            double multasCobradas, int materialesConsultados) {

            this.idEmpleado = Objects.requireNonNull(idEmpleado, "El empleado es obligatorio");
            if (diaApertura < 1) {
                throw new IllegalArgumentException("Dia invalido: " + diaApertura);
            }
            if (multasCobradas < 0) {
                throw new IllegalArgumentException("Multas negativas: " + multasCobradas);
            }
            this.diaApertura = diaApertura;
            this.operaciones = new ArrayList<>(operaciones);
            this.prestamosRealizados = prestamosRealizados;
            this.devolucionesRealizadas = devolucionesRealizadas;
            this.multasCobradas = multasCobradas;
            this.materialesConsultados = Math.max(0, materialesConsultados);
        }

        /**
         * Migracion y validacion.
         *
         * Un fichero de la version 1 no contiene 'materialesConsultados', asi
         * que llega con 0. Como no podemos distinguir ese 0 de un 0 real,
         * aplicamos una HEURISTICA razonable y DEJAMOS CONSTANCIA en el log:
         * quien consulto materiales al menos consulto los que presto.
         */
        private void readObject(ObjectInputStream entrada)
                throws IOException, ClassNotFoundException {

            entrada.defaultReadObject();

            // --- VALIDACION (el constructor no se ha ejecutado) ---
            if (idEmpleado == null || idEmpleado.isBlank()) {
                throw new InvalidObjectException("Sesion sin empleado: fichero corrupto");
            }
            if (diaApertura < 1) {
                throw new InvalidObjectException("Dia invalido: " + diaApertura);
            }
            if (multasCobradas < 0) {
                throw new InvalidObjectException("Multas negativas: " + multasCobradas);
            }
            if (operaciones == null) {
                throw new InvalidObjectException("Lista de operaciones nula");
            }

            // --- MIGRACION DE VERSION ---
            if (materialesConsultados == 0 && prestamosRealizados > 0) {
                versionDetectada = 1;
                materialesConsultados = prestamosRealizados;

                LOG.info(() -> String.format(
                        "Sesion de %s guardada con la version 1 del formato: se estima "
                                + "materialesConsultados = %d a partir de los prestamos",
                        idEmpleado, prestamosRealizados));
            } else {
                versionDetectada = 2;
            }

            if (materialesConsultados < 0) {
                materialesConsultados = 0;
            }
        }

        public String getIdEmpleado()          { return idEmpleado; }
        public int getDiaApertura()            { return diaApertura; }
        public List<String> getOperaciones()   { return List.copyOf(operaciones); }
        public int getPrestamosRealizados()    { return prestamosRealizados; }
        public int getDevolucionesRealizadas() { return devolucionesRealizadas; }
        public double getMultasCobradas()      { return multasCobradas; }
        public int getMaterialesConsultados()  { return materialesConsultados; }
        public int getVersionDetectada()       { return versionDetectada; }

        public String getResumen() {
            return String.format(
                    "Sesion de %s (dia %d, formato v%d): %d prestamos, %d devoluciones, "
                            + "%d consultas, %.2f EUR",
                    idEmpleado, diaApertura, versionDetectada, prestamosRealizados,
                    devolucionesRealizadas, materialesConsultados, multasCobradas);
        }
    }

    // ------------------------- OPERACIONES -------------------------

    public void guardar(EstadoSesion estado) throws IOException {
        Objects.requireNonNull(estado, "El estado no puede ser nulo");

        File destino = new File(directorio, estado.getIdEmpleado() + EXTENSION);
        File temporal = new File(destino.getAbsolutePath() + ".tmp");
        boolean completado = false;

        try {
            try (ObjectOutputStream salida = new ObjectOutputStream(
                    new BufferedOutputStream(new FileOutputStream(temporal)))) {
                salida.writeObject(estado);
            }
            if (destino.exists() && !destino.delete()) {
                throw new IOException("No se pudo sustituir " + destino.getName());
            }
            if (!temporal.renameTo(destino)) {
                throw new IOException("No se pudo renombrar " + temporal.getName());
            }
            completado = true;
            LOG.info(() -> "Sesion guardada: " + destino.getName());

        } finally {
            if (!completado && temporal.exists() && !temporal.delete()) {
                LOG.warning(() -> "Temporal sin borrar: " + temporal.getAbsolutePath());
            }
        }
    }

    public java.util.Optional<EstadoSesion> restaurar(String idEmpleado) {
        File fichero = new File(directorio, idEmpleado + EXTENSION);
        if (!fichero.exists()) {
            return java.util.Optional.empty();
        }
        try {
            return java.util.Optional.of(leer(fichero));
        } catch (Exception e) {
            LOG.log(Level.WARNING, "No se pudo restaurar " + fichero.getName(), e);
            return java.util.Optional.empty();
        }
    }

    /** Lectura con filtro. Lanza para que quien llame decida. */
    private EstadoSesion leer(File fichero) throws IOException, ClassNotFoundException {
        try (ObjectInputStream entrada = new ObjectInputStream(
                new BufferedInputStream(new FileInputStream(fichero)))) {

            FiltroDeserializacion.aplicarA(entrada);
            return (EstadoSesion) entrada.readObject();
        }
    }

    // ------------------------- INFORME Y LIMPIEZA -------------------------

    /** Estado de un fichero de sesion del directorio. */
    public record InfoSesion(String nombre, long tamano, boolean legible,
                             String detalle) { }

    /**
     * Informe de todas las sesiones guardadas.
     *
     * Intenta leer cada una y clasifica el resultado. NO propaga: el informe
     * debe poder generarse aunque haya ficheros rotos, que es precisamente
     * cuando mas falta hace.
     */
    public List<InfoSesion> listarSesiones() {
        List<InfoSesion> informe = new ArrayList<>();

        File[] ficheros = directorio.listFiles(
                (dir, nombre) -> nombre.endsWith(EXTENSION));

        if (ficheros == null) {                        // puede ser null (07-01)
            LOG.warning("No se pudo listar " + directorio.getAbsolutePath());
            return informe;
        }

        Arrays.sort(ficheros);                          // orden estable (05-09)

        for (File f : ficheros) {
            try {
                EstadoSesion estado = leer(f);
                informe.add(new InfoSesion(f.getName(), f.length(), true,
                        estado.getResumen()));

            } catch (InvalidClassException e) {
                informe.add(new InfoSesion(f.getName(), f.length(), false,
                        "Version de clase incompatible"));

            } catch (InvalidObjectException e) {
                informe.add(new InfoSesion(f.getName(), f.length(), false,
                        "Rechazada por validacion: " + e.getMessage()));

            } catch (StreamCorruptedException | EOFException e) {
                informe.add(new InfoSesion(f.getName(), f.length(), false,
                        "Fichero corrupto o truncado"));

            } catch (ClassNotFoundException e) {
                informe.add(new InfoSesion(f.getName(), f.length(), false,
                        "Clase no encontrada: " + e.getMessage()));

            } catch (IOException e) {
                informe.add(new InfoSesion(f.getName(), f.length(), false,
                        "Fallo de E/S: " + e.getMessage()));
            }
        }
        return informe;
    }

    /**
     * Aparta los ficheros ilegibles renombrandolos.
     *
     * NO los borra: un fichero ilegible puede hacer falta para diagnosticar
     * por que dejo de serlo.
     *
     * @return cuantos se apartaron
     */
    public int limpiarSesionesInvalidas() {
        int apartados = 0;

        for (InfoSesion info : listarSesiones()) {
            if (info.legible()) {
                continue;
            }
            File origen = new File(directorio, info.nombre());
            File destino = new File(directorio,
                    info.nombre().replace(EXTENSION, EXTENSION_INVALIDA));

            if (destino.exists()) {
                destino.delete();
            }
            if (origen.renameTo(destino)) {
                apartados++;
                LOG.info(() -> "Apartada sesion ilegible: " + destino.getName()
                        + " (" + info.detalle() + ")");
            } else {
                LOG.warning(() -> "No se pudo apartar " + origen.getName());
            }
        }
        return apartados;
    }

    // ------------------------- DEMOSTRACION -------------------------

    public static void main(String[] args) throws IOException {
        GestorSesionVersionado gestor = new GestorSesionVersionado("datos/sesiones");

        // 1. Guardar tres sesiones
        gestor.guardar(new EstadoSesion("E-001", 15,
                List.of("PRESTAMO PR-0001", "DEVOLUCION PR-0001"), 1, 1, 1.75, 4));
        gestor.guardar(new EstadoSesion("E-002", 15,
                List.of("PRESTAMO PR-0002"), 1, 0, 0.0, 2));
        gestor.guardar(new EstadoSesion("E-003", 16,
                List.of(), 0, 0, 0.0, 0));

        // 2. Crear un fichero corrupto a proposito
        File corrupto = new File("datos/sesiones/E-999.sesion");
        try (FileOutputStream fos = new FileOutputStream(corrupto)) {
            fos.write("esto no es un flujo de objetos".getBytes());
        }

        // 3. Informe
        System.out.println("=== SESIONES GUARDADAS ===");
        for (InfoSesion info : gestor.listarSesiones()) {
            System.out.printf("  %-18s %6d bytes  %-10s %s%n",
                    info.nombre(), info.tamano(),
                    info.legible() ? "[OK]" : "[ERROR]", info.detalle());
        }

        // 4. Restauracion concreta
        System.out.println();
        System.out.println("=== RESTAURACION ===");
        gestor.restaurar("E-001").ifPresentOrElse(
                e -> System.out.println("  " + e.getResumen()),
                () -> System.out.println("  No se pudo restaurar E-001"));

        // 5. Limpieza
        System.out.println();
        System.out.printf("=== LIMPIEZA: %d ficheros apartados ===%n",
                gestor.limpiarSesionesInvalidas());
    }
}

=== SESIONES GUARDADAS ===
  E-001.sesion          287 bytes  [OK]       Sesion de E-001 (dia 15, formato v2): 1 prestamos, 1 devoluciones, 4 consultas, 1,75 EUR
  E-002.sesion          256 bytes  [OK]       Sesion de E-002 (dia 15, formato v2): 1 prestamos, 0 devoluciones, 2 consultas, 0,00 EUR
  E-003.sesion          231 bytes  [OK]       Sesion de E-003 (dia 16, formato v2): 0 prestamos, 0 devoluciones, 0 consultas, 0,00 EUR
  E-999.sesion           30 bytes  [ERROR]    Fichero corrupto o truncado

=== RESTAURACION ===
  Sesion de E-001 (dia 15, formato v2): 1 prestamos, 1 devoluciones, 4 consultas, 1,75 EUR

=== LIMPIEZA: 1 ficheros apartados ===