// ACCES NORMAL: tot es resol en COMPILACIO
Llibre llibre = new Llibre("Java Eficac", "978-0000000001");
String titol = llibre.getTitol();

// ACCES PER REFLEXIO: tot es resol en EXECUCIO
Class<?> tipus = Class.forName("com.nexussoftware.bibliotech.domini.Llibre");
Object llibre = tipus.getDeclaredConstructor(String.class, String.class)
                     .newInstance("Java Eficac", "978-0000000001");
Method metode = tipus.getMethod("getTitol");
String titol = (String) metode.invoke(llibre);

// 1. LITERAL DE CLASSE: .class sobre el nom del tipus
Class<Llibre> tipus1 = Llibre.class;

// 2. DES D UNA INSTANCIA: getClass()
Llibre llibre = new Llibre("Java Eficac", "978-0000000001");
Class<? extends Llibre> tipus2 = llibre.getClass();

// 3. DES DEL SEU NOM COMPLET: Class.forName
Class<?> tipus3 = Class.forName("com.nexussoftware.bibliotech.domini.Llibre");

Material m = new Llibre("Java Eficac", "978-0000000001");
System.out.println(m.getClass().getSimpleName());   // Llibre, no Material

Class<?> senseInicialitzar = Class.forName(
        "com.nexussoftware.bibliotech.domini.Llibre",
        false,                                  // no inicialitzar
        Thread.currentThread().getContextClassLoader());

System.out.println(int.class.getName());          // int
System.out.println(Integer.class.getName());      // java.lang.Integer  (diferents)
System.out.println(String[].class.getName());     // [Ljava.lang.String;
System.out.println(int[][].class.getName());      // [[I
System.out.println(void.class.getName());         // void

package com.nexussoftware.bibliotech;

import java.lang.reflect.Modifier;
import java.util.Arrays;

public class InspectorDeClasses {

    public static void descriure(Class<?> tipus) {

        System.out.println("=== " + tipus.getSimpleName() + " ===");

        // --- NOMS ---
        System.out.println("getName():          " + tipus.getName());
        System.out.println("getSimpleName():    " + tipus.getSimpleName());
        System.out.println("getCanonicalName(): " + tipus.getCanonicalName());
        System.out.println("getPackageName():   " + tipus.getPackageName());

        // --- JERARQUIA ---
        Class<?> pare = tipus.getSuperclass();
        System.out.println("superclasse:        " + (pare == null ? "cap" : pare.getSimpleName()));

        System.out.println("interficies:        " + Arrays.toString(
                Arrays.stream(tipus.getInterfaces()).map(Class::getSimpleName).toArray()));

        // Cadena completa d herencia fins a Object
        StringBuilder cadena = new StringBuilder(tipus.getSimpleName());
        for (Class<?> c = tipus.getSuperclass(); c != null; c = c.getSuperclass()) {
            cadena.append(" -> ").append(c.getSimpleName());
        }
        System.out.println("cadena:             " + cadena);

        // --- MODIFICADORS ---
        int mods = tipus.getModifiers();
        System.out.println("modificadors:       " + Modifier.toString(mods));
        System.out.println("  es public:        " + Modifier.isPublic(mods));
        System.out.println("  es abstract:      " + Modifier.isAbstract(mods));
        System.out.println("  es final:         " + Modifier.isFinal(mods));
        System.out.println();
    }

    public static void main(String[] args) {
        descriure(Llibre.class);
        descriure(Material.class);
        descriure(Gravetat.class);
    }
}

=== Llibre ===
getName():          com.nexussoftware.bibliotech.domini.Llibre
getSimpleName():    Llibre
getCanonicalName(): com.nexussoftware.bibliotech.domini.Llibre
getPackageName():   com.nexussoftware.bibliotech.domini
superclasse:        Material
interficies:        []
cadena:             Llibre -> Material -> Object
modificadors:       public
  es public:        true
  es abstract:      false
  es final:         false

=== Material ===
getName():          com.nexussoftware.bibliotech.domini.Material
getSimpleName():    Material
getCanonicalName(): com.nexussoftware.bibliotech.domini.Material
getPackageName():   com.nexussoftware.bibliotech.domini
superclasse:        Object
interficies:        [Identificable]
cadena:             Material -> Object
modificadors:       public abstract
  es public:        true
  es abstract:      true
  es final:         false

public static String classificar(Class<?> tipus) {
    if (tipus.isPrimitive())   return "primitiu";
    if (tipus.isArray())       return "array de " + tipus.getComponentType().getSimpleName();
    if (tipus.isEnum())        return "enum amb " + tipus.getEnumConstants().length + " constants";
    if (tipus.isRecord())      return "record amb " + tipus.getRecordComponents().length + " components";
    if (tipus.isAnnotation())  return "anotacio";
    if (tipus.isInterface())   return "interficie";
    if (tipus.isSealed())      return "classe segellada";   // Java 17, veure 10-06
    if (Modifier.isAbstract(tipus.getModifiers())) return "classe abstracta";
    return "classe concreta";
}

System.out.println(Llibre.class         + " -> " + classificar(Llibre.class));
System.out.println(Material.class       + " -> " + classificar(Material.class));
System.out.println(Gravetat.class       + " -> " + classificar(Gravetat.class));
System.out.println(Fitxa.class          + " -> " + classificar(Fitxa.class));
System.out.println(Identificable.class  + " -> " + classificar(Identificable.class));
System.out.println(int[].class          + " -> " + classificar(int[].class));
System.out.println(CampCsv.class        + " -> " + classificar(CampCsv.class));

class ...Llibre -> classe concreta
class ...Material -> classe abstracta
class ...Gravetat -> enum amb 3 constants
class ...Fitxa -> record amb 3 components
interface ...Identificable -> interficie
class [I -> array de int
interface ...CampCsv -> anotacio

for (Object constant : Gravetat.class.getEnumConstants()) {
    System.out.println("  - " + constant);
}

for (RecordComponent comp : Fitxa.class.getRecordComponents()) {
    System.out.printf("  %s %s (accessor: %s)%n",
            comp.getType().getSimpleName(), comp.getName(), comp.getAccessor().getName());
}

  String isbn (accessor: isbn)
  String titol (accessor: titol)
  boolean disponible (accessor: disponible)

Material m = new Llibre("Java Eficac", "978-0000000001");

// isInstance: equival a  (m instanceof Llibre)
System.out.println(Llibre.class.isInstance(m));                    // true

// isAssignableFrom: es pot assignar un Llibre a una variable Material?
System.out.println(Material.class.isAssignableFrom(Llibre.class)); // true
System.out.println(Llibre.class.isAssignableFrom(Material.class)); // false

package com.nexussoftware.bibliotech;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class ComparadorDeCamps {

    public static void main(String[] args) {

        System.out.println("--- getFields() sobre Llibre ---");
        for (Field f : Llibre.class.getFields()) {
            System.out.printf("  %-12s %-10s declarat a %s%n",
                    f.getName(), Modifier.toString(f.getModifiers()),
                    f.getDeclaringClass().getSimpleName());
        }

        System.out.println("--- getDeclaredFields() sobre Llibre ---");
        for (Field f : Llibre.class.getDeclaredFields()) {
            System.out.printf("  %-12s %-20s %s%n",
                    f.getName(), Modifier.toString(f.getModifiers()),
                    f.getType().getSimpleName());
        }
    }
}

--- getFields() sobre Llibre ---
  CATEGORIA_PER_DEFECTE public static final declarat a Material
--- getDeclaredFields() sobre Llibre ---
  isbn         private final        String
  titol        private final        String
  autor        private final        String
  pagines      private final        int
  valoracio    private final        double
  prestat      private              boolean

/**
 * Tots els camps declarats a la classe i a totes les seves superclasses,
 * de la mes derivada a la mes general.
 */
public static List<Field> totsElsCamps(Class<?> tipus) {
    List<Field> camps = new ArrayList<>();
    for (Class<?> c = tipus; c != null && c != Object.class; c = c.getSuperclass()) {
        camps.addAll(Arrays.asList(c.getDeclaredFields()));
    }
    return camps;
}

Llibre llibre = new Llibre("Java Eficac", "978-0000000001", "Joshua Bloch", 412, 4.8);

Field campTitol = Llibre.class.getDeclaredField("titol");
campTitol.setAccessible(true);                    // es private (apartat 10)

String valor = (String) campTitol.get(llibre);    // LLEGIR
System.out.println(valor);                        // Java Eficac

campTitol.set(llibre, "Java Eficac 3a ed.");      // ESCRIURE
System.out.println(llibre.getTitol());            // Java Eficac 3a ed.

Field campPagines = Llibre.class.getDeclaredField("pagines");
campPagines.setAccessible(true);
int pagines = campPagines.getInt(llibre);      // sense boxing

Field constant = Material.class.getDeclaredField("CATEGORIA_PER_DEFECTE");
String valor = (String) constant.get(null);    // null: no hi ha instancia

package com.nexussoftware.bibliotech;

import java.lang.reflect.*;
import java.util.Arrays;
import java.util.Comparator;

public class InspectorDeMetodes {

    public static void main(String[] args) {

        System.out.println("getMethods():         " + Llibre.class.getMethods().length + " metodes");
        System.out.println("getDeclaredMethods(): " + Llibre.class.getDeclaredMethods().length + " metodes");
        System.out.println();

        Method[] metodes = Llibre.class.getDeclaredMethods();
        Arrays.sort(metodes, Comparator.comparing(Method::getName));   // ordre estable

        for (Method m : metodes) {

            // Filtrar els metodes PONT i SINTETICS generats pel compilador (10-01)
            if (m.isBridge() || m.isSynthetic()) {
                System.out.println("  [pont/sintetic] " + m.getName() + " -- ignorat");
                continue;
            }

            String parametres = Arrays.stream(m.getParameterTypes())
                    .map(Class::getSimpleName)
                    .reduce((a, b) -> a + ", " + b)
                    .orElse("");

            System.out.printf("  %-10s %s %s(%s)%n",
                    Modifier.toString(m.getModifiers()),
                    m.getReturnType().getSimpleName(),
                    m.getName(),
                    parametres);
        }
    }
}

getMethods():         15 metodes
getDeclaredMethods(): 8 metodes

  public     boolean equals(Object)
  public     String getAutor()
  public     String getId()
  public     String getIsbn()
  public     int getPagines()
  public     String getTitol()
  public     int hashCode()
  public     String toString()

// prestar(String, String)
Method prestar = GestorPrestecs.class.getMethod("prestar", String.class, String.class);

// Un metode sense parametres
Method llistar = GestorPrestecs.class.getMethod("llistarActius");

// Un metode privat: getDeclaredMethod
Method intern = GestorPrestecs.class.getDeclaredMethod("seguentReferencia");

for (Parameter p : prestar.getParameters()) {
    System.out.println(p.getType().getSimpleName() + " " + p.getName());
}

String arg0
String arg1

javac -parameters com/nexussoftware/bibliotech/servei/GestorPrestecs.java

String isbn
String empleat

// Constructor sense arguments
Class<?> tipus = Class.forName("com.nexussoftware.bibliotech.domini.Llibre");
Object objecte = tipus.getDeclaredConstructor().newInstance();

// Constructor amb arguments: es donen els TIPUS en cercar-lo
// i els VALORS en invocar-lo
Constructor<?> ctor = tipus.getDeclaredConstructor(
        String.class, String.class, String.class, int.class, double.class);

Object llibre = ctor.newInstance("Java Eficac", "978-0000000001", "Joshua Bloch", 412, 4.8);

Class<Llibre> tipus = Llibre.class;                    // Class<Llibre>, no Class<?>
Constructor<Llibre> ctor = tipus.getDeclaredConstructor(String.class, String.class);
Llibre llibre = ctor.newInstance("Java Eficac", "978-0000000001");   // sense conversio

Object o = tipus.newInstance();    // @Deprecated(since = "9")

// Un singleton "protegit" per constructor privat
Constructor<Configuracio> ctor = Configuracio.class.getDeclaredConstructor();
ctor.setAccessible(true);
Configuracio segona = ctor.newInstance();   // una segona instancia!

Method metode = Llibre.class.getMethod("getTitol");

// invoke(instancia, arguments...)
String titol = (String) metode.invoke(llibre);

// Metode amb arguments
Method prestar = GestorPrestecs.class.getMethod("prestar", String.class, String.class);
Object resultat = prestar.invoke(gestor, "978-0000000001", "Marta Ruiz");

// Metode estatic: instancia null
Method fabrica = Resultat.class.getMethod("exit", Object.class);
Object exit = fabrica.invoke(null, "valor");

// Metode que retorna primitiu: arriba autoboxejat
Method pagines = Llibre.class.getMethod("getPagines");
int n = (Integer) pagines.invoke(llibre);

package com.nexussoftware.bibliotech.servei;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Comparator;

public final class InspectorDeEstat {

    private InspectorDeEstat() { }

    /** Imprimeix el resultat de tots els getters sense arguments de qualsevol objecte. */
    public static void bolcar(Object objecte) {

        Class<?> tipus = objecte.getClass();
        System.out.println("Estat de " + tipus.getSimpleName() + ":");

        Method[] metodes = tipus.getMethods();
        Arrays.sort(metodes, Comparator.comparing(Method::getName));

        for (Method m : metodes) {

            boolean esGetter = (m.getName().startsWith("get") || m.getName().startsWith("is"))
                    && m.getParameterCount() == 0
                    && m.getReturnType() != void.class
                    && !m.getName().equals("getClass")          // heretat d Object
                    && !Modifier.isStatic(m.getModifiers())
                    && !m.isSynthetic();

            if (!esGetter) {
                continue;
            }

            try {
                Object valor = m.invoke(objecte);
                System.out.printf("  %-16s = %s%n", nomDePropietat(m.getName()), valor);
            } catch (ReflectiveOperationException e) {
                System.out.printf("  %-16s = <error: %s>%n",
                        nomDePropietat(m.getName()), e.getCause());
            }
        }
    }

    /** getTitol -> titol, isPrestat -> prestat */
    private static String nomDePropietat(String nomMetode) {
        String sensePrefix = nomMetode.startsWith("is")
                ? nomMetode.substring(2)
                : nomMetode.substring(3);
        return Character.toLowerCase(sensePrefix.charAt(0)) + sensePrefix.substring(1);
    }
}

InspectorDeEstat.bolcar(new Llibre("Java Eficac", "978-0000000001", "Joshua Bloch", 412, 4.8));
InspectorDeEstat.bolcar(new Prestec("PR-2026-0041", "978-0000000001", "Marta Ruiz"));

Estat de Llibre:
  autor            = Joshua Bloch
  id               = 978-0000000001
  isbn             = 978-0000000001
  pagines          = 412
  prestat          = false
  titol            = Java Eficac
  valoracio        = 4.8
Estat de Prestec:
  diaPrestec       = 120
  empleat          = Marta Ruiz
  id               = PR-2026-0041
  isbn             = 978-0000000001
  referencia       = PR-2026-0041

try {
    Object o = tipus.getDeclaredConstructor().newInstance();
} catch (ReflectiveOperationException e) {      // captura les cinc de cop
    throw new BiblioTechException("No s ha pogut instanciar " + tipus.getName(), e);
}

public class DemostracioInvocationTarget {

    public static void main(String[] args) throws Exception {

        GestorPrestecs gestor = new GestorPrestecs(cataleg, prestecs);
        Method retornar = GestorPrestecs.class.getMethod("retornar", String.class);

        try {
            retornar.invoke(gestor, "REFERENCIA-INEXISTENT");

        } catch (InvocationTargetException e) {
            // e NO es l excepcio real: es l embolcall
            System.out.println("Embolcall: " + e.getClass().getSimpleName());

            // getCause() dona l excepcio QUE DE DEBO va llancar el metode
            Throwable causa = e.getCause();
            System.out.println("Causa real: " + causa.getClass().getSimpleName()
                                              + ": " + causa.getMessage());

            // El correcte: rellancar la causa, no l embolcall
            if (causa instanceof BiblioTechException bte) {
                throw bte;
            }
            throw new BiblioTechException("Fallada en retornar per reflexio", causa);
        }
    }
}

Embolcall: InvocationTargetException
Causa real: BiblioTechException: No existeix el prestec REFERENCIA-INEXISTENT

Field camp = Llibre.class.getDeclaredField("titol");
camp.setAccessible(true);        // desactiva la comprovacio d acces
String titol = (String) camp.get(llibre);

Exception in thread "main" java.lang.IllegalAccessException:
    class Exemple cannot access a member of class Llibre with modifiers "private final"

public class TrencantElEncapsulament {

    public static void main(String[] args) throws Exception {

        Llibre llibre = new Llibre("Java Eficac", "978-0000000001", "Joshua Bloch", 412, 4.8);
        System.out.println("Abans:   " + llibre.getPagines() + " pagines");

        // El camp es private FINAL: ni tan sols la classe el pot canviar
        Field pagines = Llibre.class.getDeclaredField("pagines");
        pagines.setAccessible(true);
        pagines.setInt(llibre, -999);

        System.out.println("Despres: " + llibre.getPagines() + " pagines");
    }
}

Abans:   412 pagines
Despres: -999 pagines

public class ReflexioBloquejada {

    public static void main(String[] args) throws Exception {
        Field valor = String.class.getDeclaredField("value");
        valor.setAccessible(true);      // ja no funciona
    }
}

Exception in thread "main" java.lang.reflect.InaccessibleObjectException:
    Unable to make field private final byte[] java.lang.String.value accessible:
    module java.base does not "opens java.lang" to unnamed module @0x1b6d3586

java --add-opens java.base/java.lang=ALL-UNNAMED -cp . ElMeuPrograma

module com.nexussoftware.bibliotech {
    requires java.logging;
    requires java.net.http;

    exports com.nexussoftware.bibliotech.domini;       // us normal en compilacio
    opens com.nexussoftware.bibliotech.domini;         // a mes, reflexio profunda
}

// La te?
boolean te = camp.isAnnotationPresent(CampCsv.class);

// Obtenir-la (null si no la te)
CampCsv anotacio = camp.getAnnotation(CampCsv.class);
if (anotacio != null) {
    System.out.println(anotacio.nom() + " a la posicio " + anotacio.ordre());
}

// Totes (incloses les heretades amb @Inherited)
Annotation[] totes = tipus.getAnnotations();

// Nomes les declarades directament
Annotation[] propies = tipus.getDeclaredAnnotations();

// Repetibles: funciona amb 0, 1 o N
Responsable[] responsables = tipus.getAnnotationsByType(Responsable.class);

Annotation[][] perParametre = metode.getParameterAnnotations();
for (int i = 0; i < perParametre.length; i++) {
    System.out.println("Parametre " + i + ": " + Arrays.toString(perParametre[i]));
}

// Alternativa mes llegible des de Java 8
for (Parameter p : metode.getParameters()) {
    if (p.isAnnotationPresent(NoNul.class)) {
        System.out.println(p.getName() + " no admet null");
    }
}

package com.nexussoftware.bibliotech.persistencia;

import com.nexussoftware.bibliotech.anotacions.CampCsv;

import java.lang.reflect.Field;
import java.util.*;
import java.util.logging.Logger;

/**
 * Exportador CSV universal basat en anotacions.
 *
 * No coneix Llibre, ni Prestec, ni Fitxa. Descobreix en execucio
 * quins camps porten @CampCsv, els ordena per 'ordre' i construeix
 * capcalera i linia.
 *
 * Substitueix ExportadorCatalegCsv (07-07) i tots els
 * exportadors per-classe que caldria escriure sense aixo.
 */
public class ExportadorAnotat {

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

    private static final char SEPARADOR = ';';
    private static final String EMMASCARAT = "***";

    /**
     * Cache de la introspeccio: getDeclaredFields() es car i el
     * resultat no canvia mai per a una classe donada (apartat 17).
     */
    private final Map<Class<?>, List<Field>> cache = new HashMap<>();

    /** Si es true, els camps marcats sensible = true s emmascaren. */
    private final boolean emmascararSensibles;

    public ExportadorAnotat(boolean emmascararSensibles) {
        this.emmascararSensibles = emmascararSensibles;
    }

    // ------------------------------------------------------------------
    // API publica
    // ------------------------------------------------------------------

    /** Capcalera CSV d una classe, sense necessitat de tenir una instancia. */
    public String capcalera(Class<?> tipus) {
        StringJoiner sj = new StringJoiner(String.valueOf(SEPARADOR));
        for (Field camp : campsExportables(tipus)) {
            CampCsv meta = camp.getAnnotation(CampCsv.class);
            // nom() buit significa "fes servir el nom del camp" (10-02, apartat 10)
            String titolColumna = meta.nom().isEmpty() ? camp.getName() : meta.nom();
            sj.add(escapar(titolColumna));
        }
        return sj.toString();
    }

    /** Linia CSV d una entitat qualsevol. */
    public String linia(Object entitat) {
        Objects.requireNonNull(entitat, "entitat");

        StringJoiner sj = new StringJoiner(String.valueOf(SEPARADOR));

        for (Field camp : campsExportables(entitat.getClass())) {
            CampCsv meta = camp.getAnnotation(CampCsv.class);
            sj.add(escapar(valorDe(camp, meta, entitat)));
        }
        return sj.toString();
    }

    /** Exporta una colleccio completa: capcalera + una linia per element. */
    public List<String> exportar(Class<?> tipus, Collection<?> entitats) {
        List<String> linies = new ArrayList<>(entitats.size() + 1);
        linies.add(capcalera(tipus));
        for (Object entitat : entitats) {
            linies.add(linia(entitat));
        }
        return linies;
    }

    // ------------------------------------------------------------------
    // Introspeccio
    // ------------------------------------------------------------------

    /**
     * Camps anotats amb @CampCsv, de la classe i de TOTES les seves superclasses,
     * ordenats per l element 'ordre'.
     */
    private List<Field> campsExportables(Class<?> tipus) {

        // computeIfAbsent: la introspeccio es fa UNA vegada per classe (05-05)
        return cache.computeIfAbsent(tipus, t -> {

            List<Field> trobats = new ArrayList<>();

            // Recorregut de la jerarquia: getDeclaredFields NO veu els heretats
            for (Class<?> c = t; c != null && c != Object.class; c = c.getSuperclass()) {
                for (Field camp : c.getDeclaredFields()) {

                    if (camp.isSynthetic()) {
                        continue;            // this$0 de classes internes, etc.
                    }
                    if (!camp.isAnnotationPresent(CampCsv.class)) {
                        continue;            // sense anotacio: no s exporta
                    }

                    camp.setAccessible(true);    // son private: cal obrir-los
                    trobats.add(camp);
                }
            }

            // Ordre declarat. getDeclaredFields NO garanteix cap ordre,
            // aixi que sense aixo la sortida seria impredictible entre execucions.
            trobats.sort(Comparator.comparingInt(
                    f -> f.getAnnotation(CampCsv.class).ordre()));

            LOG.fine(() -> "Introspeccio de " + t.getSimpleName()
                    + ": " + trobats.size() + " camps exportables");

            return List.copyOf(trobats);
        });
    }

    /** Llegeix el camp i el formata segons l anotacio. */
    private String valorDe(Field camp, CampCsv meta, Object entitat) {
        try {
            Object valor = camp.get(entitat);

            if (valor == null) {
                return "";
            }
            if (emmascararSensibles && meta.sensible()) {
                return EMMASCARAT;
            }
            if (!meta.format().isEmpty()) {
                return String.format(meta.format(), valor);
            }
            return String.valueOf(valor);

        } catch (IllegalAccessException e) {
            // Nomes pot passar si setAccessible ha fallat (moduls, apartat 11)
            throw new IllegalStateException(
                    "No s ha pogut llegir el camp " + camp.getName()
                    + " de " + entitat.getClass().getSimpleName(), e);
        }
    }

    /** Escapat CSV segons RFC 4180 (07-07): cometes si hi ha separador, cometes o salt. */
    private String escapar(String valor) {
        boolean necessita = valor.indexOf(SEPARADOR) >= 0
                || valor.indexOf('"') >= 0
                || valor.indexOf('\n') >= 0
                || valor.indexOf('\r') >= 0;

        if (!necessita) {
            return valor;
        }
        return '"' + valor.replace("\"", "\"\"") + '"';
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.domini.*;
import com.nexussoftware.bibliotech.persistencia.ExportadorAnotat;

import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.List;

public class ExportacioUniversal {

    public static void main(String[] args) throws Exception {

        ExportadorAnotat exportador = new ExportadorAnotat(true);   // emmascarar sensibles

        // --- Llibres ---
        List<Llibre> llibres = List.of(
                new Llibre("978-0000000001", "Java Eficac",        "Joshua Bloch",  412, 4.85),
                new Llibre("978-0000000002", "Patrons de Disseny", "GoF",           395, 4.60),
                new Llibre("978-0000000003", "Refactoritzacio",    "Martin Fowler", 448, 4.72));

        System.out.println("--- cataleg.csv ---");
        exportador.exportar(Llibre.class, llibres).forEach(System.out::println);

        // --- Prestecs: UNA ALTRA classe, MATEIX exportador ---
        List<Prestec> prestecs = List.of(
                new Prestec("PR-2026-0041", "978-0000000001", "Marta Ruiz",   120),
                new Prestec("PR-2026-0042", "978-0000000003", "Diego Alonso", 124));

        System.out.println();
        System.out.println("--- prestecs.csv ---");
        exportador.exportar(Prestec.class, prestecs).forEach(System.out::println);

        // --- Un record: TAMBE funciona ---
        List<Fitxa> fitxes = List.of(
                new Fitxa("978-0000000001", "Java Eficac", false),
                new Fitxa("978-0000000002", "Patrons de Disseny", true));

        System.out.println();
        System.out.println("--- fitxes.csv ---");
        exportador.exportar(Fitxa.class, fitxes).forEach(System.out::println);

        // I escriure-ho a disc amb NIO.2 i UTF-8 explicit (07-06)
        Files.write(Path.of("cataleg.csv"),
                    exportador.exportar(Llibre.class, llibres),
                    StandardCharsets.UTF_8);
    }
}

--- cataleg.csv ---
ISBN;Titol;Autor;Pagines;Valoracio
978-0000000001;Java Eficac;Joshua Bloch;412;4,85
978-0000000002;Patrons de Disseny;GoF;395;4,60
978-0000000003;Refactoritzacio;Martin Fowler;448;4,72

--- prestecs.csv ---
Referencia;ISBN;Empleat;Dia prestec
PR-2026-0041;978-0000000001;***;120
PR-2026-0042;978-0000000003;***;124

--- fitxes.csv ---
ISBN;Titol;Disponible
978-0000000001;Java Eficac;false
978-0000000002;Patrons de Disseny;true

@CampCsv(nom = "Editorial", ordre = 6)
private final String editorial;

List<Llibre> llibres = new ArrayList<>();
List<String> textos = new ArrayList<>();

System.out.println(llibres.getClass());                        // class java.util.ArrayList
System.out.println(llibres.getClass() == textos.getClass());   // true

package com.nexussoftware.bibliotech.servei;

public class CatalegService {
    private Repositori<Material> cataleg;            // declaracio generica
    private Map<String, List<Prestec>> perEmpleat;

    public List<Llibre> cercarLlibres(Predicate<Material> criteri) { ... }
}

package com.nexussoftware.bibliotech;

import java.lang.reflect.*;
import java.util.Arrays;

public class InspectorDeGenerics {

    public static void main(String[] args) throws Exception {

        // --- CAMPS ---
        for (Field camp : CatalegService.class.getDeclaredFields()) {

            System.out.println("camp: " + camp.getName());
            System.out.println("  getType():        " + camp.getType().getSimpleName());
            System.out.println("  getGenericType(): " + camp.getGenericType());

            Type generic = camp.getGenericType();
            if (generic instanceof ParameterizedType pt) {
                System.out.println("  tipus cru:        "
                        + ((Class<?>) pt.getRawType()).getSimpleName());
                System.out.println("  arguments:        "
                        + Arrays.toString(pt.getActualTypeArguments()));
            }
            System.out.println();
        }

        // --- METODES ---
        Method cercar = CatalegService.class.getMethod("cercarLlibres", java.util.function.Predicate.class);
        System.out.println("metode: " + cercar.getName());
        System.out.println("  getReturnType():         " + cercar.getReturnType().getSimpleName());
        System.out.println("  getGenericReturnType():  " + cercar.getGenericReturnType());
        System.out.println("  getGenericParameterTypes(): "
                + Arrays.toString(cercar.getGenericParameterTypes()));
    }
}

camp: cataleg
  getType():        Repositori
  getGenericType(): com...Repositori<com...Material>
  tipus cru:        Repositori
  arguments:        [class com...Material]

camp: perEmpleat
  getType():        Map
  getGenericType(): java.util.Map<java.lang.String, java.util.List<com...Prestec>>
  tipus cru:        Map
  arguments:        [class java.lang.String, java.util.List<com...Prestec>]

metode: cercarLlibres
  getReturnType():         List
  getGenericReturnType():  java.util.List<com...Llibre>
  getGenericParameterTypes(): [java.util.function.Predicate<com...Material>]

// Classe anonima: la signatura de la seva superclasse SI que conserva <List<Llibre>>
var testimoni = new TestimoniDeTipus<List<Llibre>>() { };
System.out.println(testimoni.tipus());

public abstract class TestimoniDeTipus<T> {

    public Type tipus() {
        // getGenericSuperclass() de la classe anonima dona TestimoniDeTipus<List<Llibre>>
        ParameterizedType superclasse = (ParameterizedType) getClass().getGenericSuperclass();
        return superclasse.getActualTypeArguments()[0];
    }
}

java.util.List<com.nexussoftware.bibliotech.domini.Llibre>

// 1. La interficie que s implementa
public interface ServeiPrestecs {
    Resultat<Prestec> prestar(String isbn, String empleat);
    Resultat<Prestec> retornar(String referencia);
    List<Prestec> llistarActius();
}

// 2. El gestor que intercepta
InvocationHandler gestor = (proxy, metode, args) -> {
    System.out.println("Interceptat: " + metode.getName());
    return metode.invoke(objecteReal, args);
};

// 3. La fabricacio del proxy
ServeiPrestecs proxy = (ServeiPrestecs) Proxy.newProxyInstance(
        ServeiPrestecs.class.getClassLoader(),       // qui carrega la classe generada
        new Class<?>[] { ServeiPrestecs.class },     // interficies a implementar
        gestor);                                     // qui aten les crides

package com.nexussoftware.bibliotech.servei;

import java.lang.reflect.*;

public final class ProxyCronometre {

    private ProxyCronometre() { }

    @SuppressWarnings("unchecked")
    public static <T> T embolcallar(T objecte, Class<T> interficie) {
        return (T) Proxy.newProxyInstance(
                interficie.getClassLoader(),
                new Class<?>[] { interficie },
                (proxy, metode, args) -> {

                    long inici = System.nanoTime();
                    try {
                        return metode.invoke(objecte, args);

                    } catch (InvocationTargetException e) {
                        throw e.getCause();      // rellancar la causa, no l embolcall
                    } finally {
                        long ms = (System.nanoTime() - inici) / 1_000_000;
                        System.out.printf("[TEMPS] %s() -> %d ms%n", metode.getName(), ms);
                    }
                });
    }
}

ServeiPrestecs real = new GestorPrestecs(cataleg, prestecs);
ServeiPrestecs mesurat = ProxyCronometre.embolcallar(real, ServeiPrestecs.class);

mesurat.prestar("978-0000000001", "Marta Ruiz");
mesurat.llistarActius();

[TEMPS] prestar() -> 3 ms
[TEMPS] llistarActius() -> 0 ms

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.anotacions.Auditable;
import com.nexussoftware.bibliotech.domini.Gravetat;

import java.lang.reflect.*;
import java.util.Arrays;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Proxy d auditoria dirigit per anotacions.
 *
 * Intercepta cada crida, busca @Auditable al metode i, si no
 * la troba, a la classe (herencia de configuracio, com el
 * @Transactional d Spring). Registra inici, fi, durada i fallada.
 *
 * GestorPrestecs NO conte ni una linia d auditoria.
 */
public final class ProxyAuditoria implements InvocationHandler {

    private static final Logger LOG = Logger.getLogger("bibliotech.auditoria");

    private final Object objectiu;
    private final Class<?> classeObjectiu;

    private ProxyAuditoria(Object objectiu) {
        this.objectiu = objectiu;
        this.classeObjectiu = objectiu.getClass();
    }

    /** Fabrica tipada: retorna alguna cosa que es pot fer servir com la interficie original. */
    @SuppressWarnings("unchecked")
    public static <T> T auditar(T objectiu, Class<T> interficie) {
        if (!interficie.isInterface()) {
            throw new IllegalArgumentException(
                    interficie.getSimpleName() + " no es una interficie; Proxy nomes admet interficies");
        }
        return (T) Proxy.newProxyInstance(
                interficie.getClassLoader(),
                new Class<?>[] { interficie },
                new ProxyAuditoria(objectiu));
    }

    @Override
    public Object invoke(Object proxy, Method metode, Object[] args) throws Throwable {

        Auditable politica = resoldrePolitica(metode);

        if (politica == null) {
            // Sense anotacio: passar la crida sense fer res mes
            return invocar(metode, args);
        }

        String operacio = politica.value().isEmpty() ? metode.getName() : politica.value();
        Level nivell = aNivellDeLog(politica.nivell());

        String descripcioArgs = politica.registrarArguments()
                ? descriureArguments(args, politica.argumentsSensibles())
                : "(no registrats)";

        LOG.log(nivell, () -> String.format("INICI %s %s", operacio, descripcioArgs));

        long inici = System.nanoTime();
        try {
            Object resultat = invocar(metode, args);

            long ms = (System.nanoTime() - inici) / 1_000_000;
            LOG.log(nivell, () -> String.format("FI    %s en %d ms -> %s", operacio, ms, resultat));
            return resultat;

        } catch (Throwable fallada) {
            long ms = (System.nanoTime() - inici) / 1_000_000;
            // Les fallades SEMPRE es registren com a SEVERE, sigui quin sigui el nivell
            LOG.log(Level.SEVERE, fallada,
                    () -> String.format("ERROR %s despres de %d ms: %s", operacio, ms, fallada));
            throw fallada;
        }
    }

    // ------------------------------------------------------------------

    /**
     * Busca l anotacio al metode de la CLASSE REAL (no a la interficie,
     * on podria no ser-hi) i, si no n hi ha, a la classe.
     */
    private Auditable resoldrePolitica(Method metodeDeInterficie) {
        try {
            Method metodeReal = classeObjectiu.getMethod(
                    metodeDeInterficie.getName(), metodeDeInterficie.getParameterTypes());

            Auditable delMetode = metodeReal.getAnnotation(Auditable.class);
            if (delMetode != null) {
                return delMetode;
            }
        } catch (NoSuchMethodException e) {
            // No hauria de passar: el proxy implementa la interficie que la classe implementa
        }
        return classeObjectiu.getAnnotation(Auditable.class);   // valor per defecte de classe
    }

    /** Invoca el metode real desembolcallant l excepcio. */
    private Object invocar(Method metode, Object[] args) throws Throwable {
        try {
            return metode.invoke(objectiu, args);
        } catch (InvocationTargetException e) {
            throw e.getCause();          // REGLA: rellancar la causa, no l embolcall
        }
    }

    /** Emmascara els arguments marcats com a sensibles (09-06: no registrar mai credencials). */
    private String descriureArguments(Object[] args, int[] sensibles) {
        if (args == null || args.length == 0) {
            return "()";
        }
        Object[] copia = Arrays.copyOf(args, args.length);
        for (int index : sensibles) {
            if (index >= 0 && index < copia.length) {
                copia[index] = "***";
            }
        }
        return Arrays.toString(copia);
    }

    private Level aNivellDeLog(Gravetat gravetat) {
        return switch (gravetat) {
            case ALTA    -> Level.WARNING;
            case MITJANA -> Level.INFO;
            case BAIXA   -> Level.FINE;
        };
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.domini.*;
import com.nexussoftware.bibliotech.servei.*;

public class AuditoriaTransparent {

    public static void main(String[] args) {

        ConfiguracioLog.inicialitzar();     // del modul 6

        Repositori<Material> cataleg  = new Repositori<>("cataleg");
        Repositori<Prestec> prestecs  = new Repositori<>("prestecs");
        cataleg.desar(new Llibre("978-0000000001", "Java Eficac"));
        cataleg.desar(new Llibre("978-0000000002", "Patrons de Disseny"));

        // L objecte REAL, sense res d auditoria a dins
        ServeiPrestecs real = new GestorPrestecs(cataleg, prestecs);

        // L objecte que fa servir l aplicacio
        ServeiPrestecs servei = ProxyAuditoria.auditar(real, ServeiPrestecs.class);

        servei.prestar("978-0000000001", "Marta Ruiz");
        servei.prestar("978-0000000001", "Diego Alonso");   // ja prestat: retorna fallada
        servei.llistarActius();                             // sense @Auditable: no es registra
        servei.canviarClauEmpleat("Nuria Vidal", "clau-secreta-real");

        try {
            servei.retornar("PR-INEXISTENT");
        } catch (Exception e) {
            System.out.println("Excepcio rebuda pel client: "
                    + e.getClass().getSimpleName() + " -- " + e.getMessage());
        }
    }
}

[WARNING] bibliotech.auditoria: INICI prestar [978-0000000001, Marta Ruiz]
[WARNING] bibliotech.auditoria: FI    prestar en 4 ms -> Exit[Prestec[PR-2026-0001]]
[WARNING] bibliotech.auditoria: INICI prestar [978-0000000001, Diego Alonso]
[WARNING] bibliotech.auditoria: FI    prestar en 0 ms -> Fallada[El material 'Java Eficac' ja esta prestat]
[INFO]    bibliotech.auditoria: INICI canviarClau [Nuria Vidal, ***]
[INFO]    bibliotech.auditoria: FI    canviarClau en 1 ms -> Exit[null]
[WARNING] bibliotech.auditoria: INICI retornar [PR-INEXISTENT]
[SEVERE]  bibliotech.auditoria: ERROR retornar despres de 0 ms: BiblioTechException: No existeix el prestec PR-INEXISTENT
    com.nexussoftware.bibliotech.BiblioTechException: No existeix el prestec PR-INEXISTENT
        at com.nexussoftware.bibliotech.servei.GestorPrestecs.retornar(GestorPrestecs.java:78)
        ...
Excepcio rebuda pel client: BiblioTechException -- No existeix el prestec PR-INEXISTENT

// Si algu reanomena getTitol() a titol(), aixo compila igual
// i falla en execucio, potser mesos despres, potser en produccio.
Method m = tipus.getMethod("getTitol");

package com.nexussoftware.bibliotech.servei;

import java.lang.invoke.*;

public class ExempleMethodHandle {

    public static void main(String[] args) throws Throwable {

        MethodHandles.Lookup lookup = MethodHandles.lookup();

        // El TIPUS del metode es declara explicitament: (retorn, parametres...)
        MethodType tipus = MethodType.methodType(String.class);
        MethodHandle getTitol = lookup.findVirtual(Llibre.class, "getTitol", tipus);

        Llibre llibre = new Llibre("978-0000000001", "Java Eficac");

        // invokeExact exigeix que els tipus coincideixin EXACTAMENT
        String titol = (String) getTitol.invokeExact(llibre);
        System.out.println(titol);

        // VarHandle per a camps, amb semantica de memoria explicita (repren 08-04)
        VarHandle campPrestat = MethodHandles
                .privateLookupIn(Llibre.class, lookup)
                .findVarHandle(Llibre.class, "prestat", boolean.class);

        System.out.println("prestat: " + campPrestat.get(llibre));
        campPrestat.setVolatile(llibre, true);               // escriptura volatil
        System.out.println("prestat: " + campPrestat.get(llibre));

        // I operacions atomiques sense AtomicBoolean (08-06)
        boolean canviat = campPrestat.compareAndSet(llibre, true, false);
        System.out.println("compareAndSet: " + canviat);
    }
}

Java Eficac
prestat: false
prestat: true
compareAndSet: true

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.anotacions.Validar;

import java.lang.reflect.Field;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern;

/**
 * Motor de validacio dirigit per @Validar.
 * No coneix Llibre, Prestec ni cap entitat concreta.
 */
public class ValidadorAnotat {

    /** Introspeccio cacheada per classe (ConcurrentHashMap: es pot fer servir des de diversos fils). */
    private final Map<Class<?>, List<Field>> campsPerClasse = new ConcurrentHashMap<>();

    /** Patrons compilats: Pattern.compile es car i el patro no canvia. */
    private final Map<String, Pattern> patrons = new ConcurrentHashMap<>();

    // ------------------------------------------------------------------

    public <T> Resultat<T> validar(T entitat) {
        if (entitat == null) {
            return Resultat.fallada("L'entitat es nulla");
        }

        List<String> fallades = new ArrayList<>();

        for (Field camp : campsValidables(entitat.getClass())) {
            Validar regla = camp.getAnnotation(Validar.class);
            Object valor = llegir(camp, entitat);
            comprovar(camp, regla, valor, fallades);
        }

        if (fallades.isEmpty()) {
            return Resultat.exit(entitat);
        }
        return Resultat.fallada(entitat.getClass().getSimpleName()
                + " no valid: " + String.join("; ", fallades));
    }

    /** Imprimeix les regles d una classe sense instanciar-la. */
    public void descriure(Class<?> tipus) {
        System.out.println("Regles de " + tipus.getSimpleName() + ":");
        for (Field camp : campsValidables(tipus)) {
            Validar r = camp.getAnnotation(Validar.class);
            System.out.printf("  %-12s obligatori=%-5s long=[%d..%s] patro=%s%n",
                    camp.getName(),
                    r.obligatori(),
                    r.longitudMinima(),
                    r.longitudMaxima() == Integer.MAX_VALUE ? "∞" : r.longitudMaxima(),
                    r.patro().isEmpty() ? "-" : r.patro());
        }
    }

    // ------------------------------------------------------------------

    /** Camps anotats de la classe i de totes les seves superclasses. */
    private List<Field> campsValidables(Class<?> tipus) {
        return campsPerClasse.computeIfAbsent(tipus, t -> {
            List<Field> trobats = new ArrayList<>();
            for (Class<?> c = t; c != null && c != Object.class; c = c.getSuperclass()) {
                for (Field camp : c.getDeclaredFields()) {
                    if (camp.isSynthetic() || !camp.isAnnotationPresent(Validar.class)) {
                        continue;
                    }
                    camp.setAccessible(true);
                    trobats.add(camp);
                }
            }
            // Ordre estable per nom: getDeclaredFields no el garanteix
            trobats.sort(Comparator.comparing(Field::getName));
            return List.copyOf(trobats);
        });
    }

    private Object llegir(Field camp, Object entitat) {
        try {
            return camp.get(entitat);
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("No s ha pogut llegir " + camp.getName(), e);
        }
    }

    private void comprovar(Field camp, Validar regla, Object valor, List<String> fallades) {

        String nom = camp.getName();

        // 1. Obligatorietat
        if (valor == null) {
            if (regla.obligatori()) {
                fallades.add(missatge(regla, "'" + nom + "' es obligatori i esta buit"));
            }
            return;                                  // sense valor no hi ha res mes a comprovar
        }

        // Les altres regles nomes apliquen a text
        if (!(valor instanceof String text)) {
            return;
        }

        if (regla.obligatori() && text.isBlank()) {
            fallades.add(missatge(regla, "'" + nom + "' es obligatori i esta en blanc"));
            return;
        }

        // 2. Longituds
        if (text.length() < regla.longitudMinima()) {
            fallades.add(missatge(regla, String.format(
                    "'%s' necessita almenys %d caracters i en te %d",
                    nom, regla.longitudMinima(), text.length())));
        }
        if (text.length() > regla.longitudMaxima()) {
            fallades.add(missatge(regla, String.format(
                    "'%s' admet com a maxim %d caracters i en te %d",
                    nom, regla.longitudMaxima(), text.length())));
        }

        // 3. Patro
        if (!regla.patro().isEmpty()) {
            Pattern patro = patrons.computeIfAbsent(regla.patro(), Pattern::compile);
            if (!patro.matcher(text).matches()) {
                fallades.add(missatge(regla, String.format(
                        "'%s' no compleix el format %s (valor: \"%s\")",
                        nom, regla.patro(), text)));
            }
        }
    }

    /** El missatge personalitzat de l anotacio te prioritat sobre el generat. */
    private String missatge(Validar regla, String generat) {
        return regla.missatge().isEmpty() ? generat : regla.missatge();
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.domini.Llibre;
import com.nexussoftware.bibliotech.servei.*;

import java.util.List;

public class ProvaValidadorAnotat {

    public static void main(String[] args) {

        ValidadorAnotat validador = new ValidadorAnotat();

        validador.descriure(Llibre.class);
        System.out.println();

        List<Llibre> candidats = List.of(
                new Llibre("978-0000000001", "Java Eficac",     "Joshua Bloch"),
                new Llibre("978-1",          "Refactoritzacio", "Martin Fowler"),
                new Llibre("978-0000000003", "",                "A".repeat(150)));

        for (Llibre llibre : candidats) {
            Resultat<Llibre> r = validador.validar(llibre);
            System.out.println(r.esExit()
                    ? "OK       -> " + r.valor().getTitol()
                    : "REBUTJAT -> " + r.error());
        }
    }
}

Regles de Llibre:
  autor        obligatori=false long=[0..120] patro=-
  isbn         obligatori=true  long=[0..∞] patro=978-\d{10}
  titol        obligatori=true  long=[1..200] patro=-

OK       -> Java Eficac
REBUTJAT -> Llibre no valid: L ISBN ha de seguir el format 978-XXXXXXXXXX
REBUTJAT -> Llibre no valid: 'autor' admet com a maxim 120 caracters i en te 150; 'titol' es obligatori i esta en blanc

package com.nexussoftware.bibliotech.anotacions;

import java.lang.annotation.*;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Component {
    String nom() default "";
}

package com.nexussoftware.bibliotech.anotacions;

import java.lang.annotation.*;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.CONSTRUCTOR, ElementType.FIELD})
public @interface Injectar {
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.anotacions.*;

import java.lang.reflect.*;
import java.util.*;

/**
 * Contenidor d injeccio de dependencies minim.
 * Es, en essencia, el que fa l ApplicationContext d Spring
 * reduit a l imprescindible.
 */
public class ContenidorSimple {

    /** Tipus registrats com a disponibles. */
    private final Set<Class<?>> registrats = new LinkedHashSet<>();

    /** Instancies ja creades: cada component es un singleton. */
    private final Map<Class<?>, Object> instancies = new LinkedHashMap<>();

    /** Tipus que s estan creant ara mateix: serveix per detectar cicles. */
    private final Deque<Class<?>> enConstruccio = new ArrayDeque<>();

    // ------------------------------------------------------------------

    public ContenidorSimple registrar(Class<?>... classes) {
        for (Class<?> classe : classes) {
            if (!classe.isAnnotationPresent(Component.class)) {
                throw new IllegalArgumentException(
                        classe.getSimpleName() + " no esta anotada amb @Component");
            }
            registrats.add(classe);
        }
        return this;
    }

    /** Registra una instancia ja construida (per a configuracio, valors, etc.). */
    public <T> ContenidorSimple registrarInstancia(Class<T> tipus, T instancia) {
        instancies.put(tipus, instancia);
        registrats.add(tipus);
        return this;
    }

    @SuppressWarnings("unchecked")
    public <T> T obtenir(Class<T> tipus) {
        // Conversio segura: nomes desem instancies del tipus amb el qual s indexen
        return (T) resoldre(tipus);
    }

    public void llistar() {
        System.out.println("Components instanciats (" + instancies.size() + "):");
        instancies.forEach((tipus, obj) ->
                System.out.printf("  %-24s -> %s%n", tipus.getSimpleName(), obj));
    }

    // ------------------------------------------------------------------

    private Object resoldre(Class<?> tipus) {

        // 1. Ja existeix? Singleton.
        Object existent = instancies.get(tipus);
        if (existent != null) {
            return existent;
        }

        // 2. Cercar una implementacio registrada compatible
        Class<?> implementacio = cercarImplementacio(tipus);

        // 3. Detectar cicles ABANS d entrar en recursio
        if (enConstruccio.contains(implementacio)) {
            List<String> cicle = new ArrayList<>();
            for (Class<?> c : enConstruccio) {
                cicle.add(0, c.getSimpleName());
            }
            cicle.add(implementacio.getSimpleName());
            throw new IllegalStateException("Dependencia circular: " + String.join(" -> ", cicle));
        }

        enConstruccio.push(implementacio);
        try {
            Object instancia = construir(implementacio);
            injectarCamps(instancia);
            instancies.put(tipus, instancia);
            if (tipus != implementacio) {
                instancies.put(implementacio, instancia);
            }
            return instancia;
        } finally {
            enConstruccio.pop();
        }
    }

    /** Si demanen una interficie, busca l unica implementacio registrada. */
    private Class<?> cercarImplementacio(Class<?> tipus) {
        if (registrats.contains(tipus) && !tipus.isInterface()) {
            return tipus;
        }
        List<Class<?>> candidats = new ArrayList<>();
        for (Class<?> c : registrats) {
            if (tipus.isAssignableFrom(c) && !c.isInterface()
                    && !Modifier.isAbstract(c.getModifiers())) {
                candidats.add(c);
            }
        }
        if (candidats.isEmpty()) {
            throw new IllegalStateException(
                    "No hi ha cap component registrat que satisfaci " + tipus.getSimpleName());
        }
        if (candidats.size() > 1) {
            throw new IllegalStateException("Hi ha " + candidats.size()
                    + " candidats per a " + tipus.getSimpleName() + ": " + candidats);
        }
        return candidats.get(0);
    }

    /** Instancia resolent recursivament els parametres del constructor. */
    private Object construir(Class<?> classe) {

        Constructor<?> triat = triarConstructor(classe);
        triat.setAccessible(true);

        Class<?>[] tipusParametre = triat.getParameterTypes();
        Object[] arguments = new Object[tipusParametre.length];

        for (int i = 0; i < tipusParametre.length; i++) {
            arguments[i] = resoldre(tipusParametre[i]);       // RECURSIO
        }

        try {
            return triat.newInstance(arguments);
        } catch (InvocationTargetException e) {
            throw new IllegalStateException(
                    "El constructor de " + classe.getSimpleName() + " ha llancat una excepcio",
                    e.getCause());                            // la CAUSA, no l embolcall
        } catch (ReflectiveOperationException e) {
            throw new IllegalStateException("No s ha pogut instanciar " + classe.getSimpleName(), e);
        }
    }

    private Constructor<?> triarConstructor(Class<?> classe) {
        Constructor<?> senseArguments = null;

        for (Constructor<?> c : classe.getDeclaredConstructors()) {
            if (c.isAnnotationPresent(Injectar.class)) {
                return c;                                     // prioritat a l anotat
            }
            if (c.getParameterCount() == 0) {
                senseArguments = c;
            }
        }
        if (senseArguments != null) {
            return senseArguments;
        }
        // Convencio: si nomes n hi ha un, es fa servir (com fa Spring des de 4.3)
        Constructor<?>[] tots = classe.getDeclaredConstructors();
        if (tots.length == 1) {
            return tots[0];
        }
        throw new IllegalStateException(classe.getSimpleName()
                + " te diversos constructors i cap no porta @Injectar");
    }

    /** Injeccio per camp, DESPRES de construir. */
    private void injectarCamps(Object instancia) {
        for (Class<?> c = instancia.getClass(); c != null && c != Object.class; c = c.getSuperclass()) {
            for (Field camp : c.getDeclaredFields()) {
                if (!camp.isAnnotationPresent(Injectar.class)) {
                    continue;
                }
                camp.setAccessible(true);
                try {
                    camp.set(instancia, resoldre(camp.getType()));
                } catch (IllegalAccessException e) {
                    throw new IllegalStateException(
                            "No s ha pogut injectar el camp " + camp.getName(), e);
                }
            }
        }
    }
}

@Component
public class CalculadoraMultes {
    public double calcular(int diesDeRetard) { return diesDeRetard * 0.25; }
    @Override public String toString() { return "[email protected]€/dia"; }
}

@Component
public class RepositoriMaterials extends Repositori<Material> {
    public RepositoriMaterials() { super("cataleg"); }
}

@Component
public class RepositoriPrestecs extends Repositori<Prestec> {
    public RepositoriPrestecs() { super("prestecs"); }
}

@Component
public class GestorPrestecs implements ServeiPrestecs {

    private final RepositoriMaterials cataleg;
    private final RepositoriPrestecs prestecs;

    @Injectar                                  // el contenidor fara servir AQUEST constructor
    public GestorPrestecs(RepositoriMaterials cataleg, RepositoriPrestecs prestecs) {
        this.cataleg = cataleg;
        this.prestecs = prestecs;
    }

    @Injectar                                  // injeccio per camp
    private CalculadoraMultes calculadora;

    @Override public String toString() {
        return "GestorPrestecs[cataleg=" + cataleg + ", multes=" + calculadora + "]";
    }
}

public class ArrencadaAmbContenidor {

    public static void main(String[] args) {

        ContenidorSimple contenidor = new ContenidorSimple()
                .registrar(GestorPrestecs.class,
                           RepositoriMaterials.class,
                           RepositoriPrestecs.class,
                           CalculadoraMultes.class);

        // NI UN SOL new: el contenidor resol tot el graf
        ServeiPrestecs servei = contenidor.obtenir(ServeiPrestecs.class);

        System.out.println("Obtingut: " + servei);
        System.out.println();
        contenidor.llistar();

        // Singleton: dues peticions donen el MATEIX objecte
        System.out.println();
        System.out.println("Singleton? "
                + (contenidor.obtenir(CalculadoraMultes.class)
                   == contenidor.obtenir(CalculadoraMultes.class)));
    }
}

Obtingut: GestorPrestecs[cataleg=Repositori[cataleg, 0 entitats], [email protected]€/dia]

Components instanciats (5):
  RepositoriMaterials      -> Repositori[cataleg, 0 entitats]
  RepositoriPrestecs       -> Repositori[prestecs, 0 entitats]
  CalculadoraMultes        -> [email protected]€/dia
  GestorPrestecs           -> GestorPrestecs[...]
  ServeiPrestecs           -> GestorPrestecs[...]

Singleton? true

Exception in thread "main" java.lang.IllegalStateException:
    Dependencia circular: ServeiA -> ServeiB -> ServeiA

package com.nexussoftware.bibliotech.xarxa;

import com.nexussoftware.bibliotech.anotacions.Reintentable;

import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Proxy que aplica la politica de @Reintentable.
 * Substitueix la logica de reintents codificada a ma
 * dins de ClientHttpResistent (09-06).
 */
public final class ProxyReintents implements InvocationHandler {

    private static final Logger LOG = Logger.getLogger("bibliotech.reintents");

    private final Object objectiu;

    private ProxyReintents(Object objectiu) {
        this.objectiu = objectiu;
    }

    @SuppressWarnings("unchecked")
    public static <T> T ambReintents(T objectiu, Class<T> interficie) {
        return (T) Proxy.newProxyInstance(
                interficie.getClassLoader(),
                new Class<?>[] { interficie },
                new ProxyReintents(objectiu));
    }

    @Override
    public Object invoke(Object proxy, Method metode, Object[] args) throws Throwable {

        Reintentable politica = resoldrePolitica(metode);

        if (politica == null || politica.intents() <= 1) {
            return invocar(metode, args);          // sense politica: una sola vegada
        }

        List<Throwable> falladesPrevies = new ArrayList<>();
        long espera = politica.esperaInicialMs();

        for (int intent = 1; intent <= politica.intents(); intent++) {
            try {
                Object resultat = invocar(metode, args);

                if (intent > 1) {
                    int n = intent;
                    LOG.info(() -> String.format("%s() ha reeixit a l'intent %d",
                            metode.getName(), n));
                }
                return resultat;

            } catch (Throwable fallada) {

                if (!esReintentable(fallada, politica)) {
                    LOG.fine(() -> "No es reintenta " + fallada.getClass().getSimpleName()
                            + ": no es a la politica");
                    throw fallada;                  // error permanent: no insistir
                }

                falladesPrevies.add(fallada);

                if (intent == politica.intents()) {
                    // Ultim intent: adjuntar els anteriors com a suprimits (06-06)
                    for (int i = 0; i < falladesPrevies.size() - 1; i++) {
                        fallada.addSuppressed(falladesPrevies.get(i));
                    }
                    LOG.log(Level.SEVERE, () -> String.format(
                            "%s() ha exhaurit els seus %d intents", metode.getName(), politica.intents()));
                    throw fallada;
                }

                // Aleatoritzacio (jitter): evita que N clients reintentin alhora (09-06)
                long ambJitter = espera + ThreadLocalRandom.current().nextLong(espera / 2 + 1);

                int n = intent;
                LOG.warning(() -> String.format("%s() ha fallat a l'intent %d (%s); espera %d ms",
                        metode.getName(), n, fallada.getClass().getSimpleName(), ambJitter));

                dormir(ambJitter);

                espera = (long) (espera * politica.factorDeCreixement());
            }
        }
        throw new IllegalStateException("inabastable");
    }

    // ------------------------------------------------------------------

    private Reintentable resoldrePolitica(Method metodeDeInterficie) {
        try {
            Method real = objectiu.getClass().getMethod(
                    metodeDeInterficie.getName(), metodeDeInterficie.getParameterTypes());
            return real.getAnnotation(Reintentable.class);
        } catch (NoSuchMethodException e) {
            return null;
        }
    }

    private boolean esReintentable(Throwable fallada, Reintentable politica) {
        for (Class<? extends Exception> tipus : politica.excepcions()) {
            if (tipus.isInstance(fallada)) {    // isInstance: l instanceof reflexiu
                return true;
            }
        }
        return false;
    }

    private Object invocar(Method metode, Object[] args) throws Throwable {
        try {
            return metode.invoke(objectiu, args);
        } catch (InvocationTargetException e) {
            throw e.getCause();
        }
    }

    /** Respecta la interrupcio: restaura el marcador i avorta (08-02). */
    private void dormir(long ms) throws InterruptedException {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw e;
        }
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.anotacions.Reintentable;
import com.nexussoftware.bibliotech.xarxa.ProxyReintents;

import java.io.IOException;
import java.net.SocketTimeoutException;

public class ProvaProxyReintents {

    interface ServeiMetadades {
        String consultarPerIsbn(String isbn) throws IOException;
        String sempreFalla(String isbn) throws IOException;
    }

    /** Doble de prova: falla les dues primeres vegades i despres funciona. */
    static class ClientInestable implements ServeiMetadades {

        private int crides = 0;

        @Override
        @Reintentable(intents = 4, esperaInicialMs = 100, factorDeCreixement = 2.0,
                      excepcions = { SocketTimeoutException.class })
        public String consultarPerIsbn(String isbn) throws IOException {
            crides++;
            if (crides < 3) {
                throw new SocketTimeoutException("temps exhaurit (crida " + crides + ")");
            }
            return "{\"isbn\":\"" + isbn + "\",\"titol\":\"Java Eficac\"}";
        }

        @Override
        @Reintentable(intents = 3, esperaInicialMs = 50, factorDeCreixement = 3.0,
                      excepcions = { IOException.class })
        public String sempreFalla(String isbn) throws IOException {
            throw new IOException("el servei de metadades no respon");
        }
    }

    public static void main(String[] args) throws Exception {

        ConfiguracioLog.inicialitzar();

        ServeiMetadades servei =
                ProxyReintents.ambReintents(new ClientInestable(), ServeiMetadades.class);

        System.out.println("--- cas 1: es recupera al tercer intent ---");
        System.out.println("Resultat: " + servei.consultarPerIsbn("978-0000000001"));

        System.out.println();
        System.out.println("--- cas 2: exhaureix els intents ---");
        try {
            servei.sempreFalla("978-0000000002");
        } catch (IOException e) {
            System.out.println("Excepcio final: " + e.getMessage());
            System.out.println("Fallades suprimides: " + e.getSuppressed().length);
            for (Throwable s : e.getSuppressed()) {
                System.out.println("  suprimida: " + s.getMessage());
            }
        }
    }
}

--- cas 1: es recupera al tercer intent ---
[WARNING] consultarPerIsbn() ha fallat a l'intent 1 (SocketTimeoutException); espera 137 ms
[WARNING] consultarPerIsbn() ha fallat a l'intent 2 (SocketTimeoutException); espera 265 ms
[INFO]    consultarPerIsbn() ha reeixit a l'intent 3
Resultat: {"isbn":"978-0000000001","titol":"Java Eficac"}

--- cas 2: exhaureix els intents ---
[WARNING] sempreFalla() ha fallat a l'intent 1 (IOException); espera 71 ms
[WARNING] sempreFalla() ha fallat a l'intent 2 (IOException); espera 194 ms
[SEVERE]  sempreFalla() ha exhaurit els seus 3 intents
Excepcio final: el servei de metadades no respon
Fallades suprimides: 2
  suprimida: el servei de metadades no respon
  suprimida: el servei de metadades no respon