package java.io;

public interface Serializable {
    // Sense metodes. Cap.
}

package com.nexussoftware.bibliotech.domini;

import java.io.Serializable;

public class Empleat implements Serializable {

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

    private final String nom;
    private final String identificador;
    private int prestecsActius;

    // ... la resta igual que sempre
}

package com.nexussoftware.bibliotech.demo;

import java.io.*;

public class SerialitzacioBasica {

    public static void desar(Empleat empleat, String cami) throws IOException {
        try (ObjectOutputStream sortida = new ObjectOutputStream(
                new BufferedOutputStream(new FileOutputStream(cami)))) {

            sortida.writeObject(empleat);        // escriu l'objecte i tot el seu graf
        }
    }

    public static Empleat carregar(String cami) throws IOException, ClassNotFoundException {
        try (ObjectInputStream entrada = new ObjectInputStream(
                new BufferedInputStream(new FileInputStream(cami)))) {

            // readObject retorna Object: cal convertir
            return (Empleat) entrada.readObject();
        }
    }

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

        desar(marta, "dades/marta.ser");

        Empleat recuperada = carregar("dades/marta.ser");
        System.out.println(recuperada.getNom());               // Marta Ruiz
        System.out.println(recuperada.getPrestecsActius());    // 2

        // Es UN ALTRE objecte, amb el MATEIX estat
        System.out.println(marta == recuperada);               // false
        System.out.println(marta.equals(recuperada));          // true, si equals esta be (03-09)
    }
}

/** Diversos objectes: s'escriuen i es llegeixen EN EL MATEIX ORDRE. */
public static void desarDiversos(List<Empleat> empleats, String cami) throws IOException {
    try (ObjectOutputStream sortida = new ObjectOutputStream(
            new BufferedOutputStream(new FileOutputStream(cami)))) {

        sortida.writeInt(empleats.size());          // primer, quants n'hi ha
        for (Empleat e : empleats) {
            sortida.writeObject(e);
        }
    }
}

public static List<Empleat> carregarDiversos(String cami)
        throws IOException, ClassNotFoundException {

    List<Empleat> empleats = new ArrayList<>();
    try (ObjectInputStream entrada = new ObjectInputStream(
            new BufferedInputStream(new FileInputStream(cami)))) {

        int quants = entrada.readInt();
        for (int i = 0; i < quants; i++) {
            empleats.add((Empleat) entrada.readObject());
        }
    }
    return empleats;
}

sortida.writeObject(new ArrayList<>(empleats));      // un sol writeObject
// ...
List<Empleat> empleats = (List<Empleat>) entrada.readObject();

AC ED 00 05 73 72 00 2B 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 2E 45 6D 70 6C  |tech.domini.Empl|
65 61 74 00 00 00 00 00 00 00 01 02 00 03 49 00  |eat...........I.|

public class Prestec implements Serializable {

    private static final long serialVersionUID = 1L;

    private final String referencia;
    private final Material material;
    private final int diaInici;
    private int diaDevolucio = -1;

    // DERIVAT: es calcula a partir dels dies i la tarifa del material.
    // Desar-lo seria duplicar informacio, i pitjor: si la tarifa canvia,
    // el valor desat quedaria obsolet i contradiria el calculat.
    private transient double multaCalculada;
    private transient boolean multaEnCache = false;

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

public class SessioUsuari implements Serializable {

    private static final long serialVersionUID = 1L;

    private final String identificador;

    // MAI al disc. Tot el que 06-07 va dir sobre que no registrar s'aplica
    // igual, o mes, al que es persisteix: el fitxer es queda.
    private transient char[] credencial;
    private transient String tokenDeSessio;
}

public class CacheFitxes implements Serializable {

    private static final long serialVersionUID = 1L;

    // MALAMENT: en deserialitzar sera null, no un HashMap buit.
    // L'inicialitzador NO s'executa.
    private transient Map<String, Fitxa> cache = new HashMap<>();

    public void desar(String clau, Fitxa f) {
        cache.put(clau, f);         // NullPointerException despres de deserialitzar
    }
}

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

public class GestorPrestecs implements Serializable {

    private static final long serialVersionUID = 1L;

    private final Cataleg cataleg;               // serialitzable
    private final RegistrePrestecs registre;     // serialitzable

    // PROBLEMA: Logger NO es Serializable.
    // Aquest unic camp fa que TOT el GestorPrestecs falli.
    private final Logger log = Logger.getLogger(GestorPrestecs.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 GestorPrestecs implements Serializable {

    private static final long serialVersionUID = 1L;

    private final Cataleg cataleg;
    private final RegistrePrestecs registre;

    // transient: no es desa. I no cal, perque un Logger es
    // recupera amb una crida estatica en qualsevol moment.
    private transient Logger log = Logger.getLogger(GestorPrestecs.class.getName());

    /**
     * Reinicialitza el que es transient despres de la deserialitzacio (apartat 9).
     * Sense aixo, 'log' seria null i el primer us llancaria NullPointerException.
     */
    private void readObject(java.io.ObjectInputStream entrada)
            throws java.io.IOException, ClassNotFoundException {

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

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

public class Empleat implements Serializable {

    /**
     * Versio de la forma serialitzada.
     *
     * NOMES s'incrementa quan es fa un canvi INCOMPATIBLE (apartat 8).
     * Els canvis compatibles (afegir camps, metodes, canviar codi)
     * mantenen el mateix valor.
     */
    private static final long serialVersionUID = 1L;

    // ...
}

private static final long serialVersionUID = 1L;

javac -Xlint:serial *.java

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

// VERSIO 1 - es compila, s'executa i es desa un fitxer
public class Empleat implements Serializable {
    // SENSE serialVersionUID declarat: es calcula automaticament
    private final String nom;
    private final String identificador;
    private int prestecsActius;

    public Empleat(String nom, String identificador) {
        this.nom = nom;
        this.identificador = identificador;
    }
    public String getNom() { return nom; }
}

Empleat marta = new Empleat("Marta Ruiz", "E-001");
desar(marta, "dades/marta.ser");           // OK

// VERSIO 2 - nomes s'afegeix un metode
public class Empleat implements Serializable {
    private final String nom;
    private final String identificador;
    private int prestecsActius;

    public Empleat(String nom, String identificador) {
        this.nom = nom;
        this.identificador = identificador;
    }
    public String getNom() { return nom; }

    /** Metode NOU. No toca l'estat. */
    public String getInicials() {
        String[] parts = nom.split(" ");
        return "" + parts[0].charAt(0) + parts[1].charAt(0);
    }
}

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

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

package com.nexussoftware.bibliotech.servei;

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.domini.Fitxa;

/**
 * Cache de fitxes amb serialitzacio personalitzada.
 *
 * La cache NO es desa (es derivada), pero cal reconstruir-la buida en
 * carregar: si no, seria null i el primer us llancaria NullPointerException.
 */
public class CacheFitxes implements Serializable {

    private static final long serialVersionUID = 1L;

    /** static: no es serialitza. La convencio correcta per a un Logger. */
    private static final Logger LOG = Logger.getLogger(CacheFitxes.class.getName());

    private final String nom;
    private int capacitatMaxima;

    /** transient: en deserialitzar sera null si no ho arreglem. */
    private transient Map<String, Fitxa> cache = new HashMap<>();
    private transient int encerts = 0;
    private transient int fallades = 0;

    public CacheFitxes(String nom, int capacitatMaxima) {
        this.nom = java.util.Objects.requireNonNull(nom);
        if (capacitatMaxima < 1) {
            throw new IllegalArgumentException(
                    "La capacitat ha de ser com a minim 1, i era: " + capacitatMaxima);
        }
        this.capacitatMaxima = capacitatMaxima;
    }

    /**
     * Serialitzacio personalitzada.
     *
     * US 1: registrar l'operacio.
     * US 2: escriure dades addicionals despres dels camps per defecte.
     */
    private void writeObject(ObjectOutputStream sortida) throws IOException {
        LOG.fine(() -> "Serialitzant cache '" + nom + "' amb "
                + cache.size() + " entrades (que NO es desen)");

        sortida.defaultWriteObject();         // primer, els camps normals

        // Es poden escriure dades extra. Es llegiran en el MATEIX ordre.
        sortida.writeInt(cache.size());       // nomes informatiu
    }

    /**
     * Deserialitzacio personalitzada.
     *
     * US 3: reinicialitzar els camps transient.
     * US 4: VALIDAR l'estat llegit.
     */
    private void readObject(ObjectInputStream entrada)
            throws IOException, ClassNotFoundException {

        entrada.defaultReadObject();          // primer, els camps normals

        int midaAnterior = entrada.readInt();     // l'extra, en el mateix ordre

        // US 3: reinicialitzar. Sense aixo, cache seria null.
        this.cache = new HashMap<>();
        this.encerts = 0;
        this.fallades = 0;

        // US 4: VALIDAR. La deserialitzacio NO crida el constructor, aixi que
        // les seves comprovacions no s'han executat. Un fitxer manipulat o d'una
        // versio antiga pot portar valors impossibles.
        if (capacitatMaxima < 1) {
            LOG.warning(() -> "Capacitat invalida en deserialitzar ("
                    + capacitatMaxima + "); es corregeix a 100");
            this.capacitatMaxima = 100;
        }
        if (nom == null) {
            throw new java.io.InvalidObjectException(
                    "Cache deserialitzada sense nom: fitxer corrupte o manipulat");
        }

        LOG.fine(() -> "Cache '" + nom + "' restaurada buida (tenia "
                + midaAnterior + " entrades)");
    }

    public java.util.Optional<Fitxa> cercar(String clau) {
        Fitxa f = cache.get(clau);
        if (f != null) { encerts++; } else { fallades++; }
        return java.util.Optional.ofNullable(f);
    }

    public void desar(String clau, Fitxa fitxa) {
        if (cache.size() >= capacitatMaxima) {
            cache.clear();                    // politica simple de desallotjament
        }
        cache.put(clau, fitxa);
    }

    public int getEncerts()  { return encerts; }
    public int getFallades() { return fallades; }
}

/** Preserva el patro singleton en deserialitzar. */
private Object readResolve() {
    return INSTANCIA;      // es retorna la instancia unica, no la deserialitzada
}

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

public class Ubicacio implements Externalizable {

    private String sala;
    private int prestatgeria;
    private int lleixa;

    /** OBLIGATORI i PUBLIC: Externalizable el crida en deserialitzar. */
    public Ubicacio() { }

    public Ubicacio(String sala, int prestatgeria, int lleixa) {
        this.sala = sala;
        this.prestatgeria = prestatgeria;
        this.lleixa = lleixa;
    }

    @Override
    public void writeExternal(ObjectOutput sortida) throws IOException {
        sortida.writeUTF(sala);
        sortida.writeInt(prestatgeria);
        sortida.writeInt(lleixa);
    }

    @Override
    public void readExternal(ObjectInput entrada) throws IOException {
        sala = entrada.readUTF();          // el MATEIX ordre
        prestatgeria = entrada.readInt();
        lleixa = entrada.readInt();
    }
}

/** Superclasse NO serialitzable. */
public abstract class ElementInventari {

    private final String codiIntern;
    private int revisions;

    /**
     * OBLIGATORI perque les subclasses serialitzables funcionin.
     * Sense ell: InvalidClassException "no valid constructor".
     */
    protected ElementInventari() {
        this.codiIntern = "SENSE-CODI";        // valor per defecte
        this.revisions = 0;
    }

    protected ElementInventari(String codiIntern) {
        this.codiIntern = codiIntern;
        this.revisions = 0;
    }

    public String getCodiIntern() { return codiIntern; }
}

/** Subclasse SI serialitzable. */
public class Material extends ElementInventari implements Serializable {

    private static final long serialVersionUID = 1L;

    private final String titol;
    private final String referencia;
    private boolean disponible;

    // ...
}

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

// Aquest codi JA ES VULNERABLE si 'entrada' ve de fora.
// La comprovacio arriba TARD: el dany s'ha produit dins de readObject().
Object o = entrada.readObject();
if (o instanceof Prestec p) {           // <-- massa tard
    processar(p);
}

package com.nexussoftware.bibliotech.infraestructura;

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

/**
 * Filtres de deserialitzacio per a BiblioTech.
 *
 * ADVERTIMENT: un filtre REDUEIX el risc, no l'elimina. L'unica defensa
 * completa es no deserialitzar dades no fiables (apartat 12).
 */
public final class FiltreDeserialitzacio {

    private FiltreDeserialitzacio() { }

    /**
     * Filtre per llista blanca: nomes es permeten les classes de BiblioTech
     * i un conjunt minim del JDK. Tota la resta es REBUTJA.
     *
     * La llista blanca es l'unica forma correcta: una llista negra sempre
     * es queda curta, perque no pots enumerar tot el que es perillos.
     */
    public static ObjectInputFilter deBiblioTech() {
        String patro = String.join(";",
                "com.nexussoftware.bibliotech.**",   // les nostres classes
                "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",           // profunditat maxima del graf
                "maxrefs=10000",         // referencies maximes
                "maxbytes=10485760",     // 10 MB
                "maxarray=100000",       // elements maxims d'un array
                "!*");                   // REBUTJAR TOTA LA RESTA

        return ObjectInputFilter.Config.createFilter(patro);
    }

    /** Aplica el filtre a un flux concret. */
    public static void aplicarA(ObjectInputStream entrada) {
        entrada.setObjectInputFilter(deBiblioTech());
    }
}

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

    // ABANS de qualsevol readObject
    FiltreDeserialitzacio.aplicarA(entrada);

    SessioBiblioteca sessio = (SessioBiblioteca) entrada.readObject();
}

java.io.InvalidClassException: filter status: REJECTED

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

package com.nexussoftware.bibliotech.servei;

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.FiltreDeserialitzacio;

/**
 * Desa i restaura l'estat d'una sessio de treball de BiblioTech.
 *
 * PER QUE AQUI SI QUE ES ADMISSIBLE LA SERIALITZACIO NATIVA:
 *   - El fitxer l'escriu i el llegeix la MATEIXA aplicacio.
 *   - Viu al directori de dades local, no viatja per xarxa ni el puja ningu.
 *   - El seu contingut es pot REGENERAR: si es corromp, s'esborra i es comenca
 *     una sessio nova. No es la font de veritat; el cataleg en CSV ho es.
 *
 * PER QUE EL CATALEG NO FA SERVIR AIXO: el cataleg es la dada de valor, ha de
 * ser llegible, versionable i importable des d'un full de calcul. Aixo es 07-07.
 *
 * Tot i aixi s'aplica un FILTRE de deserialitzacio: defensa en profunditat.
 */
public class GestorSessio {

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

    private static final String EXTENSIO = ".sessio";

    private final File directori;

    public GestorSessio(String directoriDades) {
        this.directori = new File(
                Objects.requireNonNull(directoriDades, "El directori no pot ser nul"));
        if (!directori.exists() && !directori.mkdirs()) {
            LOG.warning("No s'ha pogut crear " + directori.getAbsolutePath());
        }
    }

    // ------------------------- L'ESTAT -------------------------

    /**
     * Instantania serialitzable de l'estat d'una sessio.
     *
     * Es una classe A PART de SessioBiblioteca a proposit: la sessio
     * gestiona recursos (bloqueigs, logger) que no s'han de serialitzar.
     * Aquesta classe nomes conte DADES.
     */
    public static class EstatSessio implements Serializable {

        /**
         * DECLARAT des del primer dia. Sense ell, afegir un metode privat
         * d'aqui a sis mesos deixaria illegibles totes les sessions desades
         * (apartat 7).
         */
        private static final long serialVersionUID = 1L;

        private final String idEmpleat;
        private final int diaObertura;
        private final List<String> operacions;
        private final int prestecsRealitzats;
        private final int devolucionsRealitzades;
        private final double multesCobrades;

        /** Derivat: es recalcula. No te sentit desar-lo. */
        private transient String resumFormatat;

        public EstatSessio(String idEmpleat, int diaObertura, List<String> operacions,
                           int prestecsRealitzats, int devolucionsRealitzades,
                           double multesCobrades) {

            this.idEmpleat = Objects.requireNonNull(idEmpleat, "L'empleat es obligatori");
            if (diaObertura < 1) {
                throw new IllegalArgumentException("Dia invalid: " + diaObertura);
            }
            if (multesCobrades < 0) {
                throw new IllegalArgumentException("Multes negatives: " + multesCobrades);
            }
            this.diaObertura = diaObertura;
            // ArrayList explicit: es serialitzable i la seva forma es estable
            this.operacions = new ArrayList<>(operacions);
            this.prestecsRealitzats = prestecsRealitzats;
            this.devolucionsRealitzades = devolucionsRealitzades;
            this.multesCobrades = multesCobrades;
        }

        /**
         * VALIDACIO en deserialitzar.
         *
         * Imprescindible: la deserialitzacio NO crida el constructor, aixi que
         * les comprovacions de dalt NO s'han executat. Un fitxer
         * corrupte o manipulat podria portar un dia negatiu o multes
         * impossibles, i la resta del sistema les donaria per bones.
         */
        private void readObject(ObjectInputStream entrada)
                throws IOException, ClassNotFoundException {

            entrada.defaultReadObject();

            if (idEmpleat == null || idEmpleat.isBlank()) {
                throw new InvalidObjectException(
                        "Sessio sense empleat: fitxer corrupte o manipulat");
            }
            if (diaObertura < 1) {
                throw new InvalidObjectException(
                        "Dia d'obertura invalid: " + diaObertura);
            }
            if (multesCobrades < 0) {
                throw new InvalidObjectException(
                        "Multes negatives: " + multesCobrades);
            }
            if (operacions == null) {
                throw new InvalidObjectException("Llista d'operacions nulla");
            }
            // El transient es recalcula sota demanda: no cal tocar-lo aqui
        }

        public String getIdEmpleat()            { return idEmpleat; }
        public int getDiaObertura()             { return diaObertura; }
        public List<String> getOperacions()     { return List.copyOf(operacions); }
        public int getPrestecsRealitzats()      { return prestecsRealitzats; }
        public int getDevolucionsRealitzades()  { return devolucionsRealitzades; }
        public double getMultesCobrades()       { return multesCobrades; }

        /** Camp derivat: es calcula la primera vegada i es desa a la cache. */
        public String getResum() {
            if (resumFormatat == null) {
                resumFormatat = String.format(
                        "Sessio de %s (dia %d): %d prestecs, %d devolucions, %.2f EUR",
                        idEmpleat, diaObertura, prestecsRealitzats,
                        devolucionsRealitzades, multesCobrades);
            }
            return resumFormatat;
        }
    }

    // ------------------------- DESAR -------------------------

    /**
     * Desa l'estat de forma ATOMICA (07-02): temporal i reanomenat.
     *
     * Una sessio desada a mitges seria pitjor que cap: en restaurar-la
     * donaria StreamCorruptedException o, pitjor, un objecte incomplet.
     */
    public void desar(EstatSessio estat) throws IOException {
        Objects.requireNonNull(estat, "L'estat no pot ser nul");

        File desti = new File(directori, estat.getIdEmpleat() + EXTENSIO);
        File temporal = new File(desti.getAbsolutePath() + ".tmp");

        boolean completat = false;
        try {
            try (ObjectOutputStream sortida = new ObjectOutputStream(
                    new BufferedOutputStream(new FileOutputStream(temporal)))) {

                sortida.writeObject(estat);
            }   // close() -> flush garantit

            if (desti.exists() && !desti.delete()) {
                throw new IOException("No s'ha pogut substituir " + desti.getName());
            }
            if (!temporal.renameTo(desti)) {
                throw new IOException("No s'ha pogut reanomenar " + temporal.getName());
            }
            completat = true;

            LOG.info(() -> String.format("Sessio de %s desada a %s (%d bytes)",
                    estat.getIdEmpleat(), desti.getName(), desti.length()));

        } finally {
            if (!completat && temporal.exists() && !temporal.delete()) {
                LOG.warning(() -> "Temporal sense esborrar: " + temporal.getAbsolutePath());
            }
        }
    }

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

    /**
     * Restaura la sessio d'un empleat.
     *
     * DEGRADACIO ELEGANT (06-07): si no hi ha sessio desada, o si esta
     * corrupta, o si la classe ha canviat, es retorna buit i es comenca de
     * zero. Perdre una sessio no es una fallada greu: les dades de valor
     * son al cataleg.
     *
     * @return Optional buit si no s'ha pogut restaurar
     */
    public java.util.Optional<EstatSessio> restaurar(String idEmpleat) {
        File fitxer = new File(directori, idEmpleat + EXTENSIO);

        if (!fitxer.exists()) {
            LOG.fine(() -> "No hi ha sessio desada per a " + idEmpleat);
            return java.util.Optional.empty();
        }

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

            // FILTRE abans de llegir res. Defensa en profunditat (apartat 13).
            FiltreDeserialitzacio.aplicarA(entrada);

            EstatSessio estat = (EstatSessio) entrada.readObject();

            LOG.info(() -> "Sessio restaurada: " + estat.getResum());
            return java.util.Optional.of(estat);

        } catch (InvalidClassException e) {
            // La classe ha canviat de forma incompatible (apartat 8).
            LOG.log(Level.WARNING, "La sessio de " + idEmpleat
                    + " es va desar amb una altra versio de l'aplicacio i no es pot llegir", e);
            descartar(fitxer);
            return java.util.Optional.empty();

        } catch (InvalidObjectException e) {
            // El nostre readObject ha rebutjat el contingut: corrupte o manipulat.
            LOG.log(Level.SEVERE, "Sessio de " + idEmpleat + " rebutjada per validacio", e);
            descartar(fitxer);
            return java.util.Optional.empty();

        } catch (StreamCorruptedException | EOFException e) {
            // Fitxer truncat: es va tallar una escriptura. L'escriptura atomica
            // de desar() ho evita, pero una fallada del disc no.
            LOG.log(Level.WARNING, "Sessio de " + idEmpleat + " corrupta", e);
            descartar(fitxer);
            return java.util.Optional.empty();

        } catch (ClassNotFoundException e) {
            // No esten IOException: necessita el seu propi catch (apartat 3)
            LOG.log(Level.SEVERE, "Classe no trobada en restaurar la sessio de "
                    + idEmpleat, e);
            return java.util.Optional.empty();

        } catch (IOException e) {
            LOG.log(Level.SEVERE, "Fallada d'E/S restaurant la sessio de " + idEmpleat, e);
            return java.util.Optional.empty();
        }
    }

    /** Aparta un fitxer illegible en lloc d'esborrar-lo: pot caldre per diagnosticar. */
    private void descartar(File fitxer) {
        File apartat = new File(fitxer.getAbsolutePath() + ".invalid");
        if (apartat.exists()) {
            apartat.delete();
        }
        if (fitxer.renameTo(apartat)) {
            LOG.info(() -> "Sessio illegible apartada com a " + apartat.getName());
        }
    }
}

public class DemoSessio {

    public static void main(String[] args) throws IOException {
        GestorSessio gestor = new GestorSessio("dades/sessions");

        // --- En arrencar: intentar restaurar ---
        gestor.restaurar("E-001").ifPresentOrElse(
                estat -> System.out.println("Continuant: " + estat.getResum()),
                ()    -> System.out.println("Sessio nova per a E-001"));

        // --- Feina del torn ---
        List<String> operacions = new ArrayList<>();
        operacions.add("PRESTEC PR-0001");
        operacions.add("PRESTEC PR-0002");
        operacions.add("DEVOLUCIO PR-0001 (multa 1,75)");

        // --- En sortir: desar ---
        gestor.desar(new GestorSessio.EstatSessio(
                "E-001", 15, operacions, 2, 1, 1.75));

        System.out.println("Sessio desada. Torna a executar per veure la restauracio.");
    }
}

Sessio nova per a E-001
Sessio desada. Torna a executar per veure la restauracio.

Continuant: Sessio de E-001 (dia 15): 2 prestecs, 1 devolucions, 1,75 EUR
Sessio desada. Torna a executar per veure la restauracio.

package com.nexussoftware.bibliotech.demo;

import java.io.*;

/**
 * Laboratori del serialVersionUID.
 *
 * COM REPRODUIR L'EXPERIMENT PRINCIPAL:
 *
 *   1. Compilar i executar amb el metode getEtiqueta() COMENTAT a DadaV1.
 *      Es genera dades/v1.ser
 *
 *   2. DESCOMENTAR getEtiqueta() (un metode PRIVAT, que no toca l'estat).
 *
 *   3. Recompilar i tornar a executar.
 *
 *   RESULTAT: en llegir dades/v1.ser s'obte
 *
 *     java.io.InvalidClassException: ...DadaV1; local class incompatible:
 *       stream classdesc serialVersionUID = -4738291056473829104,
 *       local class serialVersionUID = 8273645019283746152
 *
 *   El fitxer queda ILLEGIBLE PER SEMPRE per haver afegit un metode
 *   privat que no afecta l'estat en absolut.
 */
public class LaboratoriCompatibilitat {

    // ---------------- SENSE serialVersionUID: fragil ----------------

    static class DadaV1 implements Serializable {
        // SENSE serialVersionUID: es calcula automaticament a partir de
        // nom, camps, METODES (inclosos els privats), constructors...
        private final String referencia;
        private final String titol;
        private final int any;

        DadaV1(String referencia, String titol, int any) {
            this.referencia = referencia;
            this.titol = titol;
            this.any = any;
        }

        // PAS 2 DE L'EXPERIMENT: descomentar aixo i recompilar.
        // private String getEtiqueta() { return referencia + " - " + titol; }

        @Override
        public String toString() {
            return String.format("DadaV1[%s, %s, %d]", referencia, titol, any);
        }
    }

    // ---------------- AMB serialVersionUID: estable ----------------

    /** Versio B: tres camps, UID declarat. */
    static class DadaV2 implements Serializable {
        private static final long serialVersionUID = 1L;

        private final String referencia;
        private final String titol;
        private final int any;

        // CAMP AFEGIT a la versio 2. Compatible: els fitxers escrits
        // sense ell es llegeixen igual, i aquest camp pren el valor per defecte.
        private final String autor;

        DadaV2(String referencia, String titol, int any, String autor) {
            this.referencia = referencia;
            this.titol = titol;
            this.any = any;
            this.autor = autor;
        }

        @Override
        public String toString() {
            return String.format("DadaV2[%s, %s, %d, autor=%s]",
                    referencia, titol, any,
                    autor == null ? "(null: fitxer antic)" : autor);
        }
    }

    // ---------------- Utilitats ----------------

    static void desar(Object o, String cami) throws IOException {
        try (ObjectOutputStream sortida = new ObjectOutputStream(
                new BufferedOutputStream(new FileOutputStream(cami)))) {
            sortida.writeObject(o);
        }
    }

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

    /** Mostra l'UID que el mecanisme assigna a una classe, declarat o calculat. */
    static long uidDe(Class<?> classe) {
        ObjectStreamClass osc = ObjectStreamClass.lookup(classe);
        return (osc == null) ? 0L : osc.getSerialVersionUID();
    }

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

        System.out.println("=== UID DE CADA CLASSE ===");
        System.out.printf("  DadaV1 (sense declarar): %d%n", uidDe(DadaV1.class));
        System.out.printf("  DadaV2 (declarat)      : %d%n", uidDe(DadaV2.class));
        System.out.println("  El primer canvia en tocar la classe; el segon, mai.");
        System.out.println();

        // --- Experiment 1: sense UID declarat ---
        System.out.println("=== SENSE serialVersionUID ===");
        File v1 = new File("dades/v1.ser");

        if (!v1.exists()) {
            desar(new DadaV1("978-0000000001", "Java Eficac", 2018), v1.getPath());
            System.out.println("  Fitxer creat. ARA: descomenta getEtiqueta(),");
            System.out.println("  recompila i torna a executar.");
        } else {
            try {
                System.out.println("  Llegit: " + carregar(v1.getPath()));
                System.out.println("  (la classe no ha canviat des que es va desar)");
            } catch (InvalidClassException e) {
                System.out.println("  INCOMPATIBLE, com s'esperava:");
                System.out.println("  " + e.getMessage());
                System.out.println("  Causa: s'ha afegit un metode. El fitxer es illegible.");
            }
        }

        // --- Experiment 2: amb UID declarat i camp afegit ---
        System.out.println();
        System.out.println("=== AMB serialVersionUID ===");

        File v2 = new File("dades/v2.ser");
        desar(new DadaV2("978-0000000002", "Patrons de Disseny", 1994, "Gamma"),
                v2.getPath());
        System.out.println("  Desat i llegit: " + carregar(v2.getPath()));

        System.out.println();
        System.out.println("=== CANVIS COMPATIBLES (amb l'UID declarat) ===");
        System.out.println("  COMPATIBLES:");
        System.out.println("    - Afegir un camp        -> val null / 0 / false");
        System.out.println("    - Eliminar un camp      -> el valor del fitxer es descarta");
        System.out.println("    - Afegir o treure metodes-> cap efecte");
        System.out.println("    - Canviar el cos        -> cap efecte");
        System.out.println("    - normal <-> transient  -> com afegir o treure camp");
        System.out.println("  INCOMPATIBLES:");
        System.out.println("    - Canviar el TIPUS d'un camp  -> InvalidClassException");
        System.out.println("    - REANOMENAR un camp          -> es PERD la dada, sense error");
        System.out.println("    - Reanomenar o moure la classe-> ClassNotFoundException");
        System.out.println("    - Canviar l'herencia          -> InvalidClassException");
    }
}

package com.nexussoftware.bibliotech.util;

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

/**
 * Copia profunda mitjancant serialitzacio en memoria.
 *
 * Serialitza a un array de bytes i deserialitza des d'ell: el resultat es un
 * graf completament nou, sense cap referencia compartida amb l'original.
 * Sense tocar el disc: ByteArrayOutputStream / ByteArrayInputStream
 * (07-03).
 *
 * TRES LIMITACIONS REALS:
 *
 *   1. TOT el graf ha de ser Serializable. Un sol camp no serialitzable a
 *      qualsevol profunditat fa fallar la copia sencera (NotSerializableException).
 *
 *   2. ES LENTA. Serialitzar i deserialitzar implica reflexio, construccio
 *      de metadades i copia de bytes. Un metode de copia escrit a ma es
 *      entre deu i cent vegades mes rapid.
 *
 *   3. ELS CAMPS transient NO ES COPIEN. Queden a null o 0 a la copia,
 *      que es correcte per a una cache pero un error silencios si el camp
 *      es va marcar transient per un altre motiu.
 *
 *   I una quarta que conve tenir present: si l'objecte vingues d'una
 *   font no fiable, aquesta tecnica hereta TOTS els riscos de l'apartat
 *   12. Fes-la servir nomes amb objectes que ja tens en memoria i controles.
 */
public final class CopiaProfunda {

    private CopiaProfunda() { }

    /**
     * Copia profunda d'un objecte serialitzable.
     *
     * Retorna Object: convertir es cosa de qui crida. (Amb generics
     * quedaria millor, pero aixo es 10-01.)
     */
    public static Object copiar(Serializable original) throws IOException {
        if (original == null) {
            return null;
        }

        ByteArrayOutputStream memoria = new ByteArrayOutputStream();

        try (ObjectOutputStream sortida = new ObjectOutputStream(memoria)) {
            sortida.writeObject(original);
        }
        // ByteArrayOutputStream no cal tancar-lo: el seu close() no fa res,
        // i tancar-lo abans de toByteArray() seria un error conceptual (07-03).

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

            return entrada.readObject();

        } catch (ClassNotFoundException e) {
            // Impossible a la practica: la classe esta carregada, acabem de
            // serialitzar-la. Es tradueix a IOException per no obligar
            // qui crida a capturar una cosa que no pot passar (06-03).
            throw new IOException("Fallada impossible en copiar: classe no trobada", e);
        }
    }

    // ------------------------- DEMOSTRACIO -------------------------

    /** Objecte de prova amb una llista mutable a dins. */
    static class CarretPrestecs implements Serializable {
        private static final long serialVersionUID = 1L;

        private final String idEmpleat;
        private final List<String> referencies;
        private double totalEstimat;

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

        CarretPrestecs(String idEmpleat) {
            this.idEmpleat = idEmpleat;
            this.referencies = new ArrayList<>();
            this.notaInterna = "nota de treball";
        }

        void afegir(String referencia, double cost) {
            referencies.add(referencia);
            totalEstimat += cost;
        }

        List<String> getReferencies() { return referencies; }   // referencia mutable
        String getNotaInterna()       { return notaInterna; }

        @Override
        public String toString() {
            return String.format("Carret[%s, %s, %.2f, nota=%s]",
                    idEmpleat, referencies, totalEstimat,
                    notaInterna == null ? "(null)" : notaInterna);
        }
    }

    /** Copia manual, escrita a ma, per comparar rendiment. */
    static CarretPrestecs copiarAMa(CarretPrestecs original) {
        CarretPrestecs copia = new CarretPrestecs(original.idEmpleat);
        copia.referencies.addAll(original.referencies);      // llista nova
        copia.totalEstimat = original.totalEstimat;
        copia.notaInterna = original.notaInterna;            // aquesta SI que es copia
        return copia;
    }

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

        System.out.println("=== COPIA SUPERFICIAL (assignacio de referencia) ===");
        CarretPrestecs superficial = original;
        superficial.getReferencies().add("978-0000000003");
        System.out.println("  Original: " + original.getReferencies());
        System.out.println("  'Copia' : " + superficial.getReferencies());
        System.out.println("  Son el MATEIX objecte: " + (original == superficial));

        System.out.println();
        System.out.println("=== COPIA PROFUNDA (serialitzacio) ===");
        CarretPrestecs profunda = (CarretPrestecs) copiar(original);
        profunda.getReferencies().add("978-0000000004");

        System.out.println("  Original: " + original.getReferencies());
        System.out.println("  Copia   : " + profunda.getReferencies());
        System.out.println("  Objectes diferents     : " + (original != profunda));
        System.out.println("  Llistes diferents      : "
                + (original.getReferencies() != profunda.getReferencies()));
        System.out.println("  Nota (transient) copiada: " + profunda.getNotaInterna());

        System.out.println();
        System.out.println("=== RENDIMENT (10 000 copies) ===");

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

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

        System.out.printf("  Per serialitzacio: %5d ms%n", msSerialitzacio);
        System.out.printf("  A ma             : %5d ms%n", msManual);
        System.out.printf("  Factor           : %.1fx mes lenta%n",
                (double) msSerialitzacio / Math.max(1, msManual));
    }
}

=== COPIA SUPERFICIAL (assignacio de referencia) ===
  Original: [978-0000000001, 978-0000000002, 978-0000000003]
  'Copia' : [978-0000000001, 978-0000000002, 978-0000000003]
  Son el MATEIX objecte: true

=== COPIA PROFUNDA (serialitzacio) ===
  Original: [978-0000000001, 978-0000000002, 978-0000000003]
  Copia   : [978-0000000001, 978-0000000002, 978-0000000003, 978-0000000004]
  Objectes diferents     : true
  Llistes diferents      : true
  Nota (transient) copiada: null

=== RENDIMENT (10 000 copies) ===
  Per serialitzacio:   412 ms
  A ma             :     4 ms
  Factor           : 103.0x mes lenta

package com.nexussoftware.bibliotech.servei;

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.FiltreDeserialitzacio;

/**
 * Gestor de sessions amb suport de DUES versions de l'estat desat.
 *
 * La versio 2 afegeix el camp 'materialsConsultats' MANTENINT el mateix
 * serialVersionUID, perque afegir un camp es un canvi COMPATIBLE: els
 * fitxers de la versio 1 es continuen llegint i el camp nou arriba a 0.
 *
 * El truc es a readObject: distingir "de veritat se'n van consultar 0" de
 * "aquest fitxer es antic i no ho sap" es impossible amb el valor per
 * defecte, aixi que es fa servir un SENTINELLA explicit.
 */
public class GestorSessioVersionat {

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

    private static final String EXTENSIO = ".sessio";
    private static final String EXTENSIO_INVALIDA = ".sessio.invalid";

    private final File directori;

    public GestorSessioVersionat(String directoriDades) {
        this.directori = new File(Objects.requireNonNull(directoriDades));
        if (!directori.exists() && !directori.mkdirs()) {
            LOG.warning("No s'ha pogut crear " + directori.getAbsolutePath());
        }
    }

    // ------------------------- L'ESTAT, VERSIO 2 -------------------------

    public static class EstatSessio implements Serializable {

        /** MATEIX valor que a la versio 1: el canvi es compatible. */
        private static final long serialVersionUID = 1L;

        /** Marca "no informat", per distingir-lo d'un 0 real. */
        private static final int NO_INFORMAT = -1;

        private final String idEmpleat;
        private final int diaObertura;
        private final List<String> operacions;
        private final int prestecsRealitzats;
        private final int devolucionsRealitzades;
        private final double multesCobrades;

        /**
         * CAMP AFEGIT A LA VERSIO 2.
         *
         * No es final: readObject necessita poder corregir-lo quan el
         * fitxer ve de la versio 1.
         */
        private int materialsConsultats;

        /** Versio del format amb que es va crear. transient: es dedueix. */
        private transient int versioDetectada = 2;

        public EstatSessio(String idEmpleat, int diaObertura, List<String> operacions,
                           int prestecsRealitzats, int devolucionsRealitzades,
                           double multesCobrades, int materialsConsultats) {

            this.idEmpleat = Objects.requireNonNull(idEmpleat, "L'empleat es obligatori");
            if (diaObertura < 1) {
                throw new IllegalArgumentException("Dia invalid: " + diaObertura);
            }
            if (multesCobrades < 0) {
                throw new IllegalArgumentException("Multes negatives: " + multesCobrades);
            }
            this.diaObertura = diaObertura;
            this.operacions = new ArrayList<>(operacions);
            this.prestecsRealitzats = prestecsRealitzats;
            this.devolucionsRealitzades = devolucionsRealitzades;
            this.multesCobrades = multesCobrades;
            this.materialsConsultats = Math.max(0, materialsConsultats);
        }

        /**
         * Migracio i validacio.
         *
         * Un fitxer de la versio 1 no conte 'materialsConsultats', aixi
         * que arriba amb 0. Com que no podem distingir aquest 0 d'un 0 real,
         * apliquem una HEURISTICA raonable i DEIXEM CONSTANCIA al log:
         * qui va consultar materials com a minim va consultar els que va prestar.
         */
        private void readObject(ObjectInputStream entrada)
                throws IOException, ClassNotFoundException {

            entrada.defaultReadObject();

            // --- VALIDACIO (el constructor no s'ha executat) ---
            if (idEmpleat == null || idEmpleat.isBlank()) {
                throw new InvalidObjectException("Sessio sense empleat: fitxer corrupte");
            }
            if (diaObertura < 1) {
                throw new InvalidObjectException("Dia invalid: " + diaObertura);
            }
            if (multesCobrades < 0) {
                throw new InvalidObjectException("Multes negatives: " + multesCobrades);
            }
            if (operacions == null) {
                throw new InvalidObjectException("Llista d'operacions nulla");
            }

            // --- MIGRACIO DE VERSIO ---
            if (materialsConsultats == 0 && prestecsRealitzats > 0) {
                versioDetectada = 1;
                materialsConsultats = prestecsRealitzats;

                LOG.info(() -> String.format(
                        "Sessio de %s desada amb la versio 1 del format: s'estima "
                                + "materialsConsultats = %d a partir dels prestecs",
                        idEmpleat, prestecsRealitzats));
            } else {
                versioDetectada = 2;
            }

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

        public String getIdEmpleat()            { return idEmpleat; }
        public int getDiaObertura()             { return diaObertura; }
        public List<String> getOperacions()     { return List.copyOf(operacions); }
        public int getPrestecsRealitzats()      { return prestecsRealitzats; }
        public int getDevolucionsRealitzades()  { return devolucionsRealitzades; }
        public double getMultesCobrades()       { return multesCobrades; }
        public int getMaterialsConsultats()     { return materialsConsultats; }
        public int getVersioDetectada()         { return versioDetectada; }

        public String getResum() {
            return String.format(
                    "Sessio de %s (dia %d, format v%d): %d prestecs, %d devolucions, "
                            + "%d consultes, %.2f EUR",
                    idEmpleat, diaObertura, versioDetectada, prestecsRealitzats,
                    devolucionsRealitzades, materialsConsultats, multesCobrades);
        }
    }

    // ------------------------- OPERACIONS -------------------------

    public void desar(EstatSessio estat) throws IOException {
        Objects.requireNonNull(estat, "L'estat no pot ser nul");

        File desti = new File(directori, estat.getIdEmpleat() + EXTENSIO);
        File temporal = new File(desti.getAbsolutePath() + ".tmp");
        boolean completat = false;

        try {
            try (ObjectOutputStream sortida = new ObjectOutputStream(
                    new BufferedOutputStream(new FileOutputStream(temporal)))) {
                sortida.writeObject(estat);
            }
            if (desti.exists() && !desti.delete()) {
                throw new IOException("No s'ha pogut substituir " + desti.getName());
            }
            if (!temporal.renameTo(desti)) {
                throw new IOException("No s'ha pogut reanomenar " + temporal.getName());
            }
            completat = true;
            LOG.info(() -> "Sessio desada: " + desti.getName());

        } finally {
            if (!completat && temporal.exists() && !temporal.delete()) {
                LOG.warning(() -> "Temporal sense esborrar: " + temporal.getAbsolutePath());
            }
        }
    }

    public java.util.Optional<EstatSessio> restaurar(String idEmpleat) {
        File fitxer = new File(directori, idEmpleat + EXTENSIO);
        if (!fitxer.exists()) {
            return java.util.Optional.empty();
        }
        try {
            return java.util.Optional.of(llegir(fitxer));
        } catch (Exception e) {
            LOG.log(Level.WARNING, "No s'ha pogut restaurar " + fitxer.getName(), e);
            return java.util.Optional.empty();
        }
    }

    /** Lectura amb filtre. Llanca perque qui cridi decideixi. */
    private EstatSessio llegir(File fitxer) throws IOException, ClassNotFoundException {
        try (ObjectInputStream entrada = new ObjectInputStream(
                new BufferedInputStream(new FileInputStream(fitxer)))) {

            FiltreDeserialitzacio.aplicarA(entrada);
            return (EstatSessio) entrada.readObject();
        }
    }

    // ------------------------- INFORME I NETEJA -------------------------

    /** Estat d'un fitxer de sessio del directori. */
    public record InfoSessio(String nom, long mida, boolean llegible,
                             String detall) { }

    /**
     * Informe de totes les sessions desades.
     *
     * Intenta llegir cadascuna i classifica el resultat. NO propaga: l'informe
     * ha de poder generar-se encara que hi hagi fitxers trencats, que es precisament
     * quan mes falta fa.
     */
    public List<InfoSessio> llistarSessions() {
        List<InfoSessio> informe = new ArrayList<>();

        File[] fitxers = directori.listFiles(
                (dir, nom) -> nom.endsWith(EXTENSIO));

        if (fitxers == null) {                         // pot ser null (07-01)
            LOG.warning("No s'ha pogut llistar " + directori.getAbsolutePath());
            return informe;
        }

        Arrays.sort(fitxers);                           // ordre estable (05-09)

        for (File f : fitxers) {
            try {
                EstatSessio estat = llegir(f);
                informe.add(new InfoSessio(f.getName(), f.length(), true,
                        estat.getResum()));

            } catch (InvalidClassException e) {
                informe.add(new InfoSessio(f.getName(), f.length(), false,
                        "Versio de classe incompatible"));

            } catch (InvalidObjectException e) {
                informe.add(new InfoSessio(f.getName(), f.length(), false,
                        "Rebutjada per validacio: " + e.getMessage()));

            } catch (StreamCorruptedException | EOFException e) {
                informe.add(new InfoSessio(f.getName(), f.length(), false,
                        "Fitxer corrupte o truncat"));

            } catch (ClassNotFoundException e) {
                informe.add(new InfoSessio(f.getName(), f.length(), false,
                        "Classe no trobada: " + e.getMessage()));

            } catch (IOException e) {
                informe.add(new InfoSessio(f.getName(), f.length(), false,
                        "Fallada d'E/S: " + e.getMessage()));
            }
        }
        return informe;
    }

    /**
     * Aparta els fitxers illegibles reanomenant-los.
     *
     * NO els esborra: un fitxer illegible pot caldre per diagnosticar
     * per que va deixar de ser-ho.
     *
     * @return quants se n'han apartat
     */
    public int netejarSessionsInvalides() {
        int apartats = 0;

        for (InfoSessio info : llistarSessions()) {
            if (info.llegible()) {
                continue;
            }
            File origen = new File(directori, info.nom());
            File desti = new File(directori,
                    info.nom().replace(EXTENSIO, EXTENSIO_INVALIDA));

            if (desti.exists()) {
                desti.delete();
            }
            if (origen.renameTo(desti)) {
                apartats++;
                LOG.info(() -> "Apartada sessio illegible: " + desti.getName()
                        + " (" + info.detall() + ")");
            } else {
                LOG.warning(() -> "No s'ha pogut apartar " + origen.getName());
            }
        }
        return apartats;
    }

    // ------------------------- DEMOSTRACIO -------------------------

    public static void main(String[] args) throws IOException {
        GestorSessioVersionat gestor = new GestorSessioVersionat("dades/sessions");

        // 1. Desar tres sessions
        gestor.desar(new EstatSessio("E-001", 15,
                List.of("PRESTEC PR-0001", "DEVOLUCIO PR-0001"), 1, 1, 1.75, 4));
        gestor.desar(new EstatSessio("E-002", 15,
                List.of("PRESTEC PR-0002"), 1, 0, 0.0, 2));
        gestor.desar(new EstatSessio("E-003", 16,
                List.of(), 0, 0, 0.0, 0));

        // 2. Crear un fitxer corrupte a proposit
        File corrupte = new File("dades/sessions/E-999.sessio");
        try (FileOutputStream fos = new FileOutputStream(corrupte)) {
            fos.write("aixo no es un flux d'objectes".getBytes());
        }

        // 3. Informe
        System.out.println("=== SESSIONS DESADES ===");
        for (InfoSessio info : gestor.llistarSessions()) {
            System.out.printf("  %-18s %6d bytes  %-10s %s%n",
                    info.nom(), info.mida(),
                    info.llegible() ? "[OK]" : "[ERROR]", info.detall());
        }

        // 4. Restauracio concreta
        System.out.println();
        System.out.println("=== RESTAURACIO ===");
        gestor.restaurar("E-001").ifPresentOrElse(
                e -> System.out.println("  " + e.getResum()),
                () -> System.out.println("  No s'ha pogut restaurar E-001"));

        // 5. Neteja
        System.out.println();
        System.out.printf("=== NETEJA: %d fitxers apartats ===%n",
                gestor.netejarSessionsInvalides());
    }
}

=== SESSIONS DESADES ===
  E-001.sessio          276 bytes  [OK]       Sessio de E-001 (dia 15, format v2): 1 prestecs, 1 devolucions, 4 consultes, 1,75 EUR
  E-002.sessio          246 bytes  [OK]       Sessio de E-002 (dia 15, format v2): 1 prestecs, 0 devolucions, 2 consultes, 0,00 EUR
  E-003.sessio          222 bytes  [OK]       Sessio de E-003 (dia 16, format v2): 0 prestecs, 0 devolucions, 0 consultes, 0,00 EUR
  E-999.sessio           29 bytes  [ERROR]    Fitxer corrupte o truncat

=== RESTAURACIO ===
  Sessio de E-001 (dia 15, format v2): 1 prestecs, 1 devolucions, 4 consultes, 1,75 EUR

=== NETEJA: 1 fitxers apartats ===