// ACCESO NORMAL: todo se resuelve en COMPILACION
Libro libro = new Libro("Java Efectivo", "978-0000000001");
String titulo = libro.getTitulo();

// ACCESO POR REFLEXION: todo se resuelve en EJECUCION
Class<?> tipo = Class.forName("com.nexussoftware.bibliotech.dominio.Libro");
Object libro = tipo.getDeclaredConstructor(String.class, String.class)
                   .newInstance("Java Efectivo", "978-0000000001");
Method metodo = tipo.getMethod("getTitulo");
String titulo = (String) metodo.invoke(libro);

// 1. LITERAL DE CLASE: .class sobre el nombre del tipo
Class<Libro> tipo1 = Libro.class;

// 2. DESDE UNA INSTANCIA: getClass()
Libro libro = new Libro("Java Efectivo", "978-0000000001");
Class<? extends Libro> tipo2 = libro.getClass();

// 3. DESDE SU NOMBRE COMPLETO: Class.forName
Class<?> tipo3 = Class.forName("com.nexussoftware.bibliotech.dominio.Libro");

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

Class<?> sinInicializar = Class.forName(
        "com.nexussoftware.bibliotech.dominio.Libro",
        false,                                  // no inicializar
        Thread.currentThread().getContextClassLoader());

System.out.println(int.class.getName());          // int
System.out.println(Integer.class.getName());      // java.lang.Integer  (distintos)
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 InspectorDeClases {

    public static void describir(Class<?> tipo) {

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

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

        // --- JERARQUIA ---
        Class<?> padre = tipo.getSuperclass();
        System.out.println("superclase:         " + (padre == null ? "ninguna" : padre.getSimpleName()));

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

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

        // --- MODIFICADORES ---
        int mods = tipo.getModifiers();
        System.out.println("modificadores:      " + 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) {
        describir(Libro.class);
        describir(Material.class);
        describir(Gravedad.class);
    }
}

=== Libro ===
getName():          com.nexussoftware.bibliotech.dominio.Libro
getSimpleName():    Libro
getCanonicalName(): com.nexussoftware.bibliotech.dominio.Libro
getPackageName():   com.nexussoftware.bibliotech.dominio
superclase:         Material
interfaces:         []
cadena:             Libro -> Material -> Object
modificadores:      public
  es public:        true
  es abstract:      false
  es final:         false

=== Material ===
getName():          com.nexussoftware.bibliotech.dominio.Material
getSimpleName():    Material
getCanonicalName(): com.nexussoftware.bibliotech.dominio.Material
getPackageName():   com.nexussoftware.bibliotech.dominio
superclase:         Object
interfaces:         [Identificable]
cadena:             Material -> Object
modificadores:      public abstract
  es public:        true
  es abstract:      true
  es final:         false

public static String clasificar(Class<?> tipo) {
    if (tipo.isPrimitive())   return "primitivo";
    if (tipo.isArray())       return "array de " + tipo.getComponentType().getSimpleName();
    if (tipo.isEnum())        return "enum con " + tipo.getEnumConstants().length + " constantes";
    if (tipo.isRecord())      return "record con " + tipo.getRecordComponents().length + " componentes";
    if (tipo.isAnnotation())  return "anotación";
    if (tipo.isInterface())   return "interfaz";
    if (tipo.isSealed())      return "clase sellada";     // Java 17, ver 10-06
    if (Modifier.isAbstract(tipo.getModifiers())) return "clase abstracta";
    return "clase concreta";
}

System.out.println(Libro.class          + " -> " + clasificar(Libro.class));
System.out.println(Material.class       + " -> " + clasificar(Material.class));
System.out.println(Gravedad.class       + " -> " + clasificar(Gravedad.class));
System.out.println(Ficha.class          + " -> " + clasificar(Ficha.class));
System.out.println(Identificable.class  + " -> " + clasificar(Identificable.class));
System.out.println(int[].class          + " -> " + clasificar(int[].class));
System.out.println(CampoCsv.class       + " -> " + clasificar(CampoCsv.class));

class ...Libro -> clase concreta
class ...Material -> clase abstracta
class ...Gravedad -> enum con 3 constantes
class ...Ficha -> record con 3 componentes
interface ...Identificable -> interfaz
class [I -> array de int
interface ...CampoCsv -> anotación

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

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

  String isbn (accesor: isbn)
  String titulo (accesor: titulo)
  boolean disponible (accesor: disponible)

Material m = new Libro("Java Efectivo", "978-0000000001");

// isInstance: equivale a  (m instanceof Libro)
System.out.println(Libro.class.isInstance(m));                    // true

// isAssignableFrom: ¿se puede asignar un Libro a una variable Material?
System.out.println(Material.class.isAssignableFrom(Libro.class)); // true
System.out.println(Libro.class.isAssignableFrom(Material.class)); // false

package com.nexussoftware.bibliotech;

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

public class ComparadorDeCampos {

    public static void main(String[] args) {

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

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

--- getFields() sobre Libro ---
  CATEGORIA_POR_DEFECTO public static final declarado en Material
--- getDeclaredFields() sobre Libro ---
  isbn         private final        String
  titulo       private final        String
  autor        private final        String
  paginas      private final        int
  valoracion   private final        double
  prestado     private              boolean

/**
 * Todos los campos declarados en la clase y en todas sus superclases,
 * de la mas derivada a la mas general.
 */
public static List<Field> todosLosCampos(Class<?> tipo) {
    List<Field> campos = new ArrayList<>();
    for (Class<?> c = tipo; c != null && c != Object.class; c = c.getSuperclass()) {
        campos.addAll(Arrays.asList(c.getDeclaredFields()));
    }
    return campos;
}

Libro libro = new Libro("Java Efectivo", "978-0000000001", "Joshua Bloch", 412, 4.8);

Field campoTitulo = Libro.class.getDeclaredField("titulo");
campoTitulo.setAccessible(true);                    // es private (apartado 10)

String valor = (String) campoTitulo.get(libro);     // LEER
System.out.println(valor);                          // Java Efectivo

campoTitulo.set(libro, "Java Efectivo 3ª ed.");     // ESCRIBIR
System.out.println(libro.getTitulo());              // Java Efectivo 3ª ed.

Field campoPaginas = Libro.class.getDeclaredField("paginas");
campoPaginas.setAccessible(true);
int paginas = campoPaginas.getInt(libro);      // sin boxing

Field constante = Material.class.getDeclaredField("CATEGORIA_POR_DEFECTO");
String valor = (String) constante.get(null);   // null: no hay instancia

package com.nexussoftware.bibliotech;

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

public class InspectorDeMetodos {

    public static void main(String[] args) {

        System.out.println("getMethods():         " + Libro.class.getMethods().length + " métodos");
        System.out.println("getDeclaredMethods(): " + Libro.class.getDeclaredMethods().length + " métodos");
        System.out.println();

        Method[] metodos = Libro.class.getDeclaredMethods();
        Arrays.sort(metodos, Comparator.comparing(Method::getName));   // orden estable

        for (Method m : metodos) {

            // Filtrar los metodos PUENTE y SINTETICOS generados por el compilador (10-01)
            if (m.isBridge() || m.isSynthetic()) {
                System.out.println("  [puente/sintético] " + m.getName() + " -- ignorado");
                continue;
            }

            String parametros = 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(),
                    parametros);
        }
    }
}

getMethods():         15 métodos
getDeclaredMethods(): 8 métodos

  public     boolean equals(Object)
  public     String getAutor()
  public     String getId()
  public     String getIsbn()
  public     int getPaginas()
  public     String getTitulo()
  public     int hashCode()
  public     String toString()

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

// Un metodo sin parametros
Method listar = GestorPrestamos.class.getMethod("listarActivos");

// Un metodo privado: getDeclaredMethod
Method interno = GestorPrestamos.class.getDeclaredMethod("siguienteReferencia");

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

String arg0
String arg1

javac -parameters com/nexussoftware/bibliotech/servicio/GestorPrestamos.java

String isbn
String empleado

// Constructor sin argumentos
Class<?> tipo = Class.forName("com.nexussoftware.bibliotech.dominio.Libro");
Object objeto = tipo.getDeclaredConstructor().newInstance();

// Constructor con argumentos: se dan los TIPOS al buscarlo
// y los VALORES al invocarlo
Constructor<?> ctor = tipo.getDeclaredConstructor(
        String.class, String.class, String.class, int.class, double.class);

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

Class<Libro> tipo = Libro.class;                       // Class<Libro>, no Class<?>
Constructor<Libro> ctor = tipo.getDeclaredConstructor(String.class, String.class);
Libro libro = ctor.newInstance("Java Efectivo", "978-0000000001");   // sin cast

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

// Un singleton "protegido" por constructor privado
Constructor<Configuracion> ctor = Configuracion.class.getDeclaredConstructor();
ctor.setAccessible(true);
Configuracion segunda = ctor.newInstance();   // ¡una segunda instancia!

Method metodo = Libro.class.getMethod("getTitulo");

// invoke(instancia, argumentos...)
String titulo = (String) metodo.invoke(libro);

// Metodo con argumentos
Method prestar = GestorPrestamos.class.getMethod("prestar", String.class, String.class);
Object resultado = prestar.invoke(gestor, "978-0000000001", "Marta Ruiz");

// Metodo estatico: instancia null
Method fabrica = Resultado.class.getMethod("exito", Object.class);
Object exito = fabrica.invoke(null, "valor");

// Metodo que devuelve primitivo: llega autoboxeado
Method paginas = Libro.class.getMethod("getPaginas");
int n = (Integer) paginas.invoke(libro);

package com.nexussoftware.bibliotech.servicio;

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

public final class InspectorDeEstado {

    private InspectorDeEstado() { }

    /** Imprime el resultado de todos los getters sin argumentos de cualquier objeto. */
    public static void volcar(Object objeto) {

        Class<?> tipo = objeto.getClass();
        System.out.println("Estado de " + tipo.getSimpleName() + ":");

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

        for (Method m : metodos) {

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

            if (!esGetter) {
                continue;
            }

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

    /** getTitulo -> titulo, isPrestado -> prestado */
    private static String nombreDePropiedad(String nombreMetodo) {
        String sinPrefijo = nombreMetodo.startsWith("is")
                ? nombreMetodo.substring(2)
                : nombreMetodo.substring(3);
        return Character.toLowerCase(sinPrefijo.charAt(0)) + sinPrefijo.substring(1);
    }
}

InspectorDeEstado.volcar(new Libro("Java Efectivo", "978-0000000001", "Joshua Bloch", 412, 4.8));
InspectorDeEstado.volcar(new Prestamo("PR-2026-0041", "978-0000000001", "Marta Ruiz"));

Estado de Libro:
  autor            = Joshua Bloch
  id               = 978-0000000001
  isbn             = 978-0000000001
  paginas          = 412
  prestado         = false
  titulo           = Java Efectivo
  valoracion       = 4.8
Estado de Prestamo:
  diaPrestamo      = 120
  empleado         = Marta Ruiz
  id               = PR-2026-0041
  isbn             = 978-0000000001
  referencia       = PR-2026-0041

try {
    Object o = tipo.getDeclaredConstructor().newInstance();
} catch (ReflectiveOperationException e) {      // captura las cinco de golpe
    throw new BiblioTechException("No se pudo instanciar " + tipo.getName(), e);
}

public class DemostracionInvocationTarget {

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

        GestorPrestamos gestor = new GestorPrestamos(catalogo, prestamos);
        Method devolver = GestorPrestamos.class.getMethod("devolver", String.class);

        try {
            devolver.invoke(gestor, "REFERENCIA-INEXISTENTE");

        } catch (InvocationTargetException e) {
            // e NO es la excepcion real: es el envoltorio
            System.out.println("Envoltorio: " + e.getClass().getSimpleName());

            // getCause() da la excepcion QUE DE VERDAD lanzo el metodo
            Throwable causa = e.getCause();
            System.out.println("Causa real: " + causa.getClass().getSimpleName()
                                              + ": " + causa.getMessage());

            // Lo correcto: relanzar la causa, no el envoltorio
            if (causa instanceof BiblioTechException bte) {
                throw bte;
            }
            throw new BiblioTechException("Fallo al devolver por reflexión", causa);
        }
    }
}

Envoltorio: InvocationTargetException
Causa real: BiblioTechException: No existe el préstamo REFERENCIA-INEXISTENTE

Field campo = Libro.class.getDeclaredField("titulo");
campo.setAccessible(true);       // desactiva la comprobacion de acceso
String titulo = (String) campo.get(libro);

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

public class RompiendoElEncapsulamiento {

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

        Libro libro = new Libro("Java Efectivo", "978-0000000001", "Joshua Bloch", 412, 4.8);
        System.out.println("Antes:   " + libro.getPaginas() + " páginas");

        // El campo es private FINAL: ni siquiera la clase puede cambiarlo
        Field paginas = Libro.class.getDeclaredField("paginas");
        paginas.setAccessible(true);
        paginas.setInt(libro, -999);

        System.out.println("Después: " + libro.getPaginas() + " páginas");
    }
}

Antes:   412 páginas
Después: -999 páginas

public class ReflexionBloqueada {

    public static void main(String[] args) throws Exception {
        Field valor = String.class.getDeclaredField("value");
        valor.setAccessible(true);      // ya 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 . MiPrograma

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

    exports com.nexussoftware.bibliotech.dominio;      // uso normal en compilacion
    opens com.nexussoftware.bibliotech.dominio;        // ademas, reflexion profunda
}

// ¿La tiene?
boolean tiene = campo.isAnnotationPresent(CampoCsv.class);

// Obtenerla (null si no la tiene)
CampoCsv anotacion = campo.getAnnotation(CampoCsv.class);
if (anotacion != null) {
    System.out.println(anotacion.nombre() + " en la posición " + anotacion.orden());
}

// Todas (incluidas las heredadas con @Inherited)
Annotation[] todas = tipo.getAnnotations();

// Solo las declaradas directamente
Annotation[] propias = tipo.getDeclaredAnnotations();

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

Annotation[][] porParametro = metodo.getParameterAnnotations();
for (int i = 0; i < porParametro.length; i++) {
    System.out.println("Parámetro " + i + ": " + Arrays.toString(porParametro[i]));
}

// Alternativa mas legible desde Java 8
for (Parameter p : metodo.getParameters()) {
    if (p.isAnnotationPresent(NoNulo.class)) {
        System.out.println(p.getName() + " no admite null");
    }
}

package com.nexussoftware.bibliotech.persistencia;

import com.nexussoftware.bibliotech.anotaciones.CampoCsv;

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

/**
 * Exportador CSV universal basado en anotaciones.
 *
 * No conoce Libro, ni Prestamo, ni Ficha. Descubre en ejecucion
 * que campos llevan @CampoCsv, los ordena por 'orden' y construye
 * cabecera y linea.
 *
 * Sustituye a ExportadorCatalogoCsv (07-07) y a todos los
 * exportadores por-clase que habria que escribir sin esto.
 */
public class ExportadorAnotado {

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

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

    /**
     * Cache de la introspeccion: getDeclaredFields() es caro y el
     * resultado no cambia nunca para una clase dada (apartado 17).
     */
    private final Map<Class<?>, List<Field>> cache = new HashMap<>();

    /** Si es true, los campos marcados sensible = true se enmascaran. */
    private final boolean enmascararSensibles;

    public ExportadorAnotado(boolean enmascararSensibles) {
        this.enmascararSensibles = enmascararSensibles;
    }

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

    /** Cabecera CSV de una clase, sin necesidad de tener una instancia. */
    public String cabecera(Class<?> tipo) {
        StringJoiner sj = new StringJoiner(String.valueOf(SEPARADOR));
        for (Field campo : camposExportables(tipo)) {
            CampoCsv meta = campo.getAnnotation(CampoCsv.class);
            // nombre() vacio significa "usa el nombre del campo" (10-02, apartado 10)
            String encabezado = meta.nombre().isEmpty() ? campo.getName() : meta.nombre();
            sj.add(escapar(encabezado));
        }
        return sj.toString();
    }

    /** Linea CSV de una entidad cualquiera. */
    public String linea(Object entidad) {
        Objects.requireNonNull(entidad, "entidad");

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

        for (Field campo : camposExportables(entidad.getClass())) {
            CampoCsv meta = campo.getAnnotation(CampoCsv.class);
            sj.add(escapar(valorDe(campo, meta, entidad)));
        }
        return sj.toString();
    }

    /** Exporta una coleccion completa: cabecera + una linea por elemento. */
    public List<String> exportar(Class<?> tipo, Collection<?> entidades) {
        List<String> lineas = new ArrayList<>(entidades.size() + 1);
        lineas.add(cabecera(tipo));
        for (Object entidad : entidades) {
            lineas.add(linea(entidad));
        }
        return lineas;
    }

    // ------------------------------------------------------------------
    // Introspeccion
    // ------------------------------------------------------------------

    /**
     * Campos anotados con @CampoCsv, de la clase y de TODAS sus superclases,
     * ordenados por el elemento 'orden'.
     */
    private List<Field> camposExportables(Class<?> tipo) {

        // computeIfAbsent: la introspeccion se hace UNA vez por clase (05-05)
        return cache.computeIfAbsent(tipo, t -> {

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

            // Recorrido de la jerarquia: getDeclaredFields NO ve los heredados
            for (Class<?> c = t; c != null && c != Object.class; c = c.getSuperclass()) {
                for (Field campo : c.getDeclaredFields()) {

                    if (campo.isSynthetic()) {
                        continue;            // this$0 de clases internas, etc.
                    }
                    if (!campo.isAnnotationPresent(CampoCsv.class)) {
                        continue;            // sin anotacion: no se exporta
                    }

                    campo.setAccessible(true);   // son private: hay que abrirlos
                    encontrados.add(campo);
                }
            }

            // Orden declarado. getDeclaredFields NO garantiza ningun orden,
            // asi que sin esto la salida seria impredecible entre ejecuciones.
            encontrados.sort(Comparator.comparingInt(
                    f -> f.getAnnotation(CampoCsv.class).orden()));

            LOG.fine(() -> "Introspección de " + t.getSimpleName()
                    + ": " + encontrados.size() + " campos exportables");

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

    /** Lee el campo y lo formatea segun la anotacion. */
    private String valorDe(Field campo, CampoCsv meta, Object entidad) {
        try {
            Object valor = campo.get(entidad);

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

        } catch (IllegalAccessException e) {
            // Solo puede pasar si setAccessible fallo (modulos, apartado 11)
            throw new IllegalStateException(
                    "No se pudo leer el campo " + campo.getName()
                    + " de " + entidad.getClass().getSimpleName(), e);
        }
    }

    /** Escapado CSV segun RFC 4180 (07-07): comillas si hay separador, comillas o salto. */
    private String escapar(String valor) {
        boolean necesita = valor.indexOf(SEPARADOR) >= 0
                || valor.indexOf('"') >= 0
                || valor.indexOf('\n') >= 0
                || valor.indexOf('\r') >= 0;

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

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.dominio.*;
import com.nexussoftware.bibliotech.persistencia.ExportadorAnotado;

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

public class ExportacionUniversal {

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

        ExportadorAnotado exportador = new ExportadorAnotado(true);   // enmascarar sensibles

        // --- Libros ---
        List<Libro> libros = List.of(
                new Libro("978-0000000001", "Java Efectivo",      "Joshua Bloch", 412, 4.85),
                new Libro("978-0000000002", "Patrones de Diseño",  "GoF",          395, 4.60),
                new Libro("978-0000000003", "Refactorización",     "Martin Fowler", 448, 4.72));

        System.out.println("--- catalogo.csv ---");
        exportador.exportar(Libro.class, libros).forEach(System.out::println);

        // --- Prestamos: OTRA clase, MISMO exportador ---
        List<Prestamo> prestamos = List.of(
                new Prestamo("PR-2026-0041", "978-0000000001", "Marta Ruiz",   120),
                new Prestamo("PR-2026-0042", "978-0000000003", "Diego Alonso", 124));

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

        // --- Un record: TAMBIEN funciona ---
        List<Ficha> fichas = List.of(
                new Ficha("978-0000000001", "Java Efectivo", false),
                new Ficha("978-0000000002", "Patrones de Diseño", true));

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

        // Y escribirlo a disco con NIO.2 y UTF-8 explicito (07-06)
        Files.write(Path.of("catalogo.csv"),
                    exportador.exportar(Libro.class, libros),
                    StandardCharsets.UTF_8);
    }
}

--- catalogo.csv ---
ISBN;Título;Autor;Páginas;Valoración
978-0000000001;Java Efectivo;Joshua Bloch;412;4,85
978-0000000002;Patrones de Diseño;GoF;395;4,60
978-0000000003;Refactorización;Martin Fowler;448;4,72

--- prestamos.csv ---
Referencia;ISBN;Empleado;Día préstamo
PR-2026-0041;978-0000000001;***;120
PR-2026-0042;978-0000000003;***;124

--- fichas.csv ---
ISBN;Título;Disponible
978-0000000001;Java Efectivo;false
978-0000000002;Patrones de Diseño;true

@CampoCsv(nombre = "Editorial", orden = 6)
private final String editorial;

List<Libro> libros = new ArrayList<>();
List<String> textos = new ArrayList<>();

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

package com.nexussoftware.bibliotech.servicio;

public class CatalogoService {
    private Repositorio<Material> catalogo;          // declaracion generica
    private Map<String, List<Prestamo>> porEmpleado;

    public List<Libro> buscarLibros(Predicate<Material> criterio) { ... }
}

package com.nexussoftware.bibliotech;

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

public class InspectorDeGenericos {

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

        // --- CAMPOS ---
        for (Field campo : CatalogoService.class.getDeclaredFields()) {

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

            Type generico = campo.getGenericType();
            if (generico instanceof ParameterizedType pt) {
                System.out.println("  tipo crudo:       "
                        + ((Class<?>) pt.getRawType()).getSimpleName());
                System.out.println("  argumentos:       "
                        + Arrays.toString(pt.getActualTypeArguments()));
            }
            System.out.println();
        }

        // --- METODOS ---
        Method buscar = CatalogoService.class.getMethod("buscarLibros", java.util.function.Predicate.class);
        System.out.println("método: " + buscar.getName());
        System.out.println("  getReturnType():         " + buscar.getReturnType().getSimpleName());
        System.out.println("  getGenericReturnType():  " + buscar.getGenericReturnType());
        System.out.println("  getGenericParameterTypes(): "
                + Arrays.toString(buscar.getGenericParameterTypes()));
    }
}

campo: catalogo
  getType():        Repositorio
  getGenericType(): com...Repositorio<com...Material>
  tipo crudo:       Repositorio
  argumentos:       [class com...Material]

campo: porEmpleado
  getType():        Map
  getGenericType(): java.util.Map<java.lang.String, java.util.List<com...Prestamo>>
  tipo crudo:       Map
  argumentos:       [class java.lang.String, java.util.List<com...Prestamo>]

método: buscarLibros
  getReturnType():         List
  getGenericReturnType():  java.util.List<com...Libro>
  getGenericParameterTypes(): [java.util.function.Predicate<com...Material>]

// Clase anonima: la firma de su superclase SI conserva <List<Libro>>
var token = new TokenDeTipo<List<Libro>>() { };
System.out.println(token.tipo());

public abstract class TokenDeTipo<T> {

    public Type tipo() {
        // getGenericSuperclass() de la clase anonima da TokenDeTipo<List<Libro>>
        ParameterizedType superclase = (ParameterizedType) getClass().getGenericSuperclass();
        return superclase.getActualTypeArguments()[0];
    }
}

java.util.List<com.nexussoftware.bibliotech.dominio.Libro>

// 1. La interfaz que se implementa
public interface ServicioPrestamos {
    Resultado<Prestamo> prestar(String isbn, String empleado);
    Resultado<Prestamo> devolver(String referencia);
    List<Prestamo> listarActivos();
}

// 2. El manejador que intercepta
InvocationHandler manejador = (proxy, metodo, args) -> {
    System.out.println("Interceptado: " + metodo.getName());
    return metodo.invoke(objetoReal, args);
};

// 3. La fabricacion del proxy
ServicioPrestamos proxy = (ServicioPrestamos) Proxy.newProxyInstance(
        ServicioPrestamos.class.getClassLoader(),      // quien carga la clase generada
        new Class<?>[] { ServicioPrestamos.class },    // interfaces a implementar
        manejador);                                    // quien atiende las llamadas

package com.nexussoftware.bibliotech.servicio;

import java.lang.reflect.*;

public final class ProxyCronometro {

    private ProxyCronometro() { }

    @SuppressWarnings("unchecked")
    public static <T> T envolver(T objeto, Class<T> interfaz) {
        return (T) Proxy.newProxyInstance(
                interfaz.getClassLoader(),
                new Class<?>[] { interfaz },
                (proxy, metodo, args) -> {

                    long inicio = System.nanoTime();
                    try {
                        return metodo.invoke(objeto, args);

                    } catch (InvocationTargetException e) {
                        throw e.getCause();      // relanzar la causa, no el envoltorio
                    } finally {
                        long ms = (System.nanoTime() - inicio) / 1_000_000;
                        System.out.printf("[TIEMPO] %s() -> %d ms%n", metodo.getName(), ms);
                    }
                });
    }
}

ServicioPrestamos real = new GestorPrestamos(catalogo, prestamos);
ServicioPrestamos medido = ProxyCronometro.envolver(real, ServicioPrestamos.class);

medido.prestar("978-0000000001", "Marta Ruiz");
medido.listarActivos();

[TIEMPO] prestar() -> 3 ms
[TIEMPO] listarActivos() -> 0 ms

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.anotaciones.Auditable;
import com.nexussoftware.bibliotech.dominio.Gravedad;

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

/**
 * Proxy de auditoria dirigido por anotaciones.
 *
 * Intercepta cada llamada, busca @Auditable en el metodo y, si no
 * la encuentra, en la clase (herencia de configuracion, como el
 * @Transactional de Spring). Registra inicio, fin, duracion y fallo.
 *
 * GestorPrestamos NO contiene ni una linea de auditoria.
 */
public final class ProxyAuditoria implements InvocationHandler {

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

    private final Object objetivo;
    private final Class<?> claseObjetivo;

    private ProxyAuditoria(Object objetivo) {
        this.objetivo = objetivo;
        this.claseObjetivo = objetivo.getClass();
    }

    /** Fabrica tipada: devuelve algo que se puede usar como la interfaz original. */
    @SuppressWarnings("unchecked")
    public static <T> T auditar(T objetivo, Class<T> interfaz) {
        if (!interfaz.isInterface()) {
            throw new IllegalArgumentException(
                    interfaz.getSimpleName() + " no es una interfaz; Proxy solo admite interfaces");
        }
        return (T) Proxy.newProxyInstance(
                interfaz.getClassLoader(),
                new Class<?>[] { interfaz },
                new ProxyAuditoria(objetivo));
    }

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

        Auditable politica = resolverPolitica(metodo);

        if (politica == null) {
            // Sin anotacion: pasar la llamada sin hacer nada mas
            return invocar(metodo, args);
        }

        String operacion = politica.value().isEmpty() ? metodo.getName() : politica.value();
        Level nivel = aNivelDeLog(politica.nivel());

        String descripcionArgs = politica.registrarArgumentos()
                ? describirArgumentos(args, politica.argumentosSensibles())
                : "(no registrados)";

        LOG.log(nivel, () -> String.format("INICIO %s %s", operacion, descripcionArgs));

        long inicio = System.nanoTime();
        try {
            Object resultado = invocar(metodo, args);

            long ms = (System.nanoTime() - inicio) / 1_000_000;
            LOG.log(nivel, () -> String.format("FIN    %s en %d ms -> %s", operacion, ms, resultado));
            return resultado;

        } catch (Throwable fallo) {
            long ms = (System.nanoTime() - inicio) / 1_000_000;
            // Los fallos SIEMPRE se registran como SEVERE, sea cual sea el nivel
            LOG.log(Level.SEVERE, fallo,
                    () -> String.format("ERROR  %s tras %d ms: %s", operacion, ms, fallo));
            throw fallo;
        }
    }

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

    /**
     * Busca la anotacion en el metodo de la CLASE REAL (no en la interfaz,
     * donde podria no estar) y, si no la hay, en la clase.
     */
    private Auditable resolverPolitica(Method metodoDeInterfaz) {
        try {
            Method metodoReal = claseObjetivo.getMethod(
                    metodoDeInterfaz.getName(), metodoDeInterfaz.getParameterTypes());

            Auditable delMetodo = metodoReal.getAnnotation(Auditable.class);
            if (delMetodo != null) {
                return delMetodo;
            }
        } catch (NoSuchMethodException e) {
            // No deberia ocurrir: el proxy implementa la interfaz que la clase implementa
        }
        return claseObjetivo.getAnnotation(Auditable.class);   // valor por defecto de clase
    }

    /** Invoca el metodo real desenvolviendo la excepcion. */
    private Object invocar(Method metodo, Object[] args) throws Throwable {
        try {
            return metodo.invoke(objetivo, args);
        } catch (InvocationTargetException e) {
            throw e.getCause();          // REGLA: relanzar la causa, no el envoltorio
        }
    }

    /** Enmascara los argumentos marcados como sensibles (09-06: nunca registrar credenciales). */
    private String describirArgumentos(Object[] args, int[] sensibles) {
        if (args == null || args.length == 0) {
            return "()";
        }
        Object[] copia = Arrays.copyOf(args, args.length);
        for (int indice : sensibles) {
            if (indice >= 0 && indice < copia.length) {
                copia[indice] = "***";
            }
        }
        return Arrays.toString(copia);
    }

    private Level aNivelDeLog(Gravedad gravedad) {
        return switch (gravedad) {
            case ALTA  -> Level.WARNING;
            case MEDIA -> Level.INFO;
            case BAJA  -> Level.FINE;
        };
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.dominio.*;
import com.nexussoftware.bibliotech.servicio.*;

public class AuditoriaTransparente {

    public static void main(String[] args) {

        ConfiguracionLog.inicializar();     // del modulo 6

        Repositorio<Material> catalogo  = new Repositorio<>("catálogo");
        Repositorio<Prestamo> prestamos = new Repositorio<>("préstamos");
        catalogo.guardar(new Libro("978-0000000001", "Java Efectivo"));
        catalogo.guardar(new Libro("978-0000000002", "Patrones de Diseño"));

        // El objeto REAL, sin nada de auditoria dentro
        ServicioPrestamos real = new GestorPrestamos(catalogo, prestamos);

        // El objeto que usa la aplicacion
        ServicioPrestamos servicio = ProxyAuditoria.auditar(real, ServicioPrestamos.class);

        servicio.prestar("978-0000000001", "Marta Ruiz");
        servicio.prestar("978-0000000001", "Diego Alonso");   // ya prestado: devuelve fallo
        servicio.listarActivos();                             // sin @Auditable: no se registra
        servicio.cambiarClaveEmpleado("Nuria Vidal", "clave-secreta-real");

        try {
            servicio.devolver("PR-INEXISTENTE");
        } catch (Exception e) {
            System.out.println("Excepción recibida por el cliente: "
                    + e.getClass().getSimpleName() + " -- " + e.getMessage());
        }
    }
}

[WARNING] bibliotech.auditoria: INICIO prestar [978-0000000001, Marta Ruiz]
[WARNING] bibliotech.auditoria: FIN    prestar en 4 ms -> Éxito[Prestamo[PR-2026-0001]]
[WARNING] bibliotech.auditoria: INICIO prestar [978-0000000001, Diego Alonso]
[WARNING] bibliotech.auditoria: FIN    prestar en 0 ms -> Fallo[El material 'Java Efectivo' ya está prestado]
[INFO]    bibliotech.auditoria: INICIO cambiarClave [Nuria Vidal, ***]
[INFO]    bibliotech.auditoria: FIN    cambiarClave en 1 ms -> Éxito[null]
[WARNING] bibliotech.auditoria: INICIO devolver [PR-INEXISTENTE]
[SEVERE]  bibliotech.auditoria: ERROR  devolver tras 0 ms: BiblioTechException: No existe el préstamo PR-INEXISTENTE
    com.nexussoftware.bibliotech.BiblioTechException: No existe el préstamo PR-INEXISTENTE
        at com.nexussoftware.bibliotech.servicio.GestorPrestamos.devolver(GestorPrestamos.java:78)
        ...
Excepción recibida por el cliente: BiblioTechException -- No existe el préstamo PR-INEXISTENTE

// Si alguien renombra getTitulo() a titulo(), esto compila igual
// y falla en ejecucion, quiza meses despues, quiza en produccion.
Method m = tipo.getMethod("getTitulo");

package com.nexussoftware.bibliotech.servicio;

import java.lang.invoke.*;

public class EjemploMethodHandle {

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

        MethodHandles.Lookup lookup = MethodHandles.lookup();

        // El TIPO del metodo se declara explicitamente: (retorno, parametros...)
        MethodType tipo = MethodType.methodType(String.class);
        MethodHandle getTitulo = lookup.findVirtual(Libro.class, "getTitulo", tipo);

        Libro libro = new Libro("978-0000000001", "Java Efectivo");

        // invokeExact exige que los tipos coincidan EXACTAMENTE
        String titulo = (String) getTitulo.invokeExact(libro);
        System.out.println(titulo);

        // VarHandle para campos, con semantica de memoria explicita (retoma 08-04)
        VarHandle campoPrestado = MethodHandles
                .privateLookupIn(Libro.class, lookup)
                .findVarHandle(Libro.class, "prestado", boolean.class);

        System.out.println("prestado: " + campoPrestado.get(libro));
        campoPrestado.setVolatile(libro, true);              // escritura volatil
        System.out.println("prestado: " + campoPrestado.get(libro));

        // Y operaciones atomicas sin AtomicBoolean (08-06)
        boolean cambiado = campoPrestado.compareAndSet(libro, true, false);
        System.out.println("compareAndSet: " + cambiado);
    }
}

Java Efectivo
prestado: false
prestado: true
compareAndSet: true

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.anotaciones.Validar;

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

/**
 * Motor de validacion dirigido por @Validar.
 * No conoce Libro, Prestamo ni ninguna entidad concreta.
 */
public class ValidadorAnotado {

    /** Introspeccion cacheada por clase (ConcurrentHashMap: puede usarse desde varios hilos). */
    private final Map<Class<?>, List<Field>> camposPorClase = new ConcurrentHashMap<>();

    /** Patrones compilados: Pattern.compile es caro y el patron no cambia. */
    private final Map<String, Pattern> patrones = new ConcurrentHashMap<>();

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

    public <T> Resultado<T> validar(T entidad) {
        if (entidad == null) {
            return Resultado.fallo("La entidad es nula");
        }

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

        for (Field campo : camposValidables(entidad.getClass())) {
            Validar regla = campo.getAnnotation(Validar.class);
            Object valor = leer(campo, entidad);
            comprobar(campo, regla, valor, fallos);
        }

        if (fallos.isEmpty()) {
            return Resultado.exito(entidad);
        }
        return Resultado.fallo(entidad.getClass().getSimpleName()
                + " no válido: " + String.join("; ", fallos));
    }

    /** Imprime las reglas de una clase sin instanciarla. */
    public void describir(Class<?> tipo) {
        System.out.println("Reglas de " + tipo.getSimpleName() + ":");
        for (Field campo : camposValidables(tipo)) {
            Validar r = campo.getAnnotation(Validar.class);
            System.out.printf("  %-12s obligatorio=%-5s long=[%d..%s] patrón=%s%n",
                    campo.getName(),
                    r.obligatorio(),
                    r.longitudMinima(),
                    r.longitudMaxima() == Integer.MAX_VALUE ? "∞" : r.longitudMaxima(),
                    r.patron().isEmpty() ? "-" : r.patron());
        }
    }

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

    /** Campos anotados de la clase y de todas sus superclases. */
    private List<Field> camposValidables(Class<?> tipo) {
        return camposPorClase.computeIfAbsent(tipo, t -> {
            List<Field> encontrados = new ArrayList<>();
            for (Class<?> c = t; c != null && c != Object.class; c = c.getSuperclass()) {
                for (Field campo : c.getDeclaredFields()) {
                    if (campo.isSynthetic() || !campo.isAnnotationPresent(Validar.class)) {
                        continue;
                    }
                    campo.setAccessible(true);
                    encontrados.add(campo);
                }
            }
            // Orden estable por nombre: getDeclaredFields no lo garantiza
            encontrados.sort(Comparator.comparing(Field::getName));
            return List.copyOf(encontrados);
        });
    }

    private Object leer(Field campo, Object entidad) {
        try {
            return campo.get(entidad);
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("No se pudo leer " + campo.getName(), e);
        }
    }

    private void comprobar(Field campo, Validar regla, Object valor, List<String> fallos) {

        String nombre = campo.getName();

        // 1. Obligatoriedad
        if (valor == null) {
            if (regla.obligatorio()) {
                fallos.add(mensaje(regla, "'" + nombre + "' es obligatorio y está vacío"));
            }
            return;                                  // sin valor no hay mas que comprobar
        }

        // Las demas reglas solo aplican a texto
        if (!(valor instanceof String texto)) {
            return;
        }

        if (regla.obligatorio() && texto.isBlank()) {
            fallos.add(mensaje(regla, "'" + nombre + "' es obligatorio y está en blanco"));
            return;
        }

        // 2. Longitudes
        if (texto.length() < regla.longitudMinima()) {
            fallos.add(mensaje(regla, String.format(
                    "'%s' necesita al menos %d caracteres y tiene %d",
                    nombre, regla.longitudMinima(), texto.length())));
        }
        if (texto.length() > regla.longitudMaxima()) {
            fallos.add(mensaje(regla, String.format(
                    "'%s' admite como máximo %d caracteres y tiene %d",
                    nombre, regla.longitudMaxima(), texto.length())));
        }

        // 3. Patron
        if (!regla.patron().isEmpty()) {
            Pattern patron = patrones.computeIfAbsent(regla.patron(), Pattern::compile);
            if (!patron.matcher(texto).matches()) {
                fallos.add(mensaje(regla, String.format(
                        "'%s' no cumple el formato %s (valor: \"%s\")",
                        nombre, regla.patron(), texto)));
            }
        }
    }

    /** El mensaje personalizado de la anotacion tiene prioridad sobre el generado. */
    private String mensaje(Validar regla, String generado) {
        return regla.mensaje().isEmpty() ? generado : regla.mensaje();
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.dominio.Libro;
import com.nexussoftware.bibliotech.servicio.*;

import java.util.List;

public class PruebaValidadorAnotado {

    public static void main(String[] args) {

        ValidadorAnotado validador = new ValidadorAnotado();

        validador.describir(Libro.class);
        System.out.println();

        List<Libro> candidatos = List.of(
                new Libro("978-0000000001", "Java Efectivo",  "Joshua Bloch"),
                new Libro("978-1",          "Refactorización", "Martin Fowler"),
                new Libro("978-0000000003", "",                "A".repeat(150)));

        for (Libro libro : candidatos) {
            Resultado<Libro> r = validador.validar(libro);
            System.out.println(r.esExito()
                    ? "OK      -> " + r.valor().getTitulo()
                    : "RECHAZO -> " + r.error());
        }
    }
}

Reglas de Libro:
  autor        obligatorio=false long=[0..120] patrón=-
  isbn         obligatorio=true  long=[0..∞] patrón=978-\d{10}
  titulo       obligatorio=true  long=[1..200] patrón=-

OK      -> Java Efectivo
RECHAZO -> Libro no válido: El ISBN debe seguir el formato 978-XXXXXXXXXX
RECHAZO -> Libro no válido: 'autor' admite como máximo 120 caracteres y tiene 150; 'titulo' es obligatorio y está en blanco

package com.nexussoftware.bibliotech.anotaciones;

import java.lang.annotation.*;

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

package com.nexussoftware.bibliotech.anotaciones;

import java.lang.annotation.*;

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

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.anotaciones.*;

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

/**
 * Contenedor de inyeccion de dependencias minimo.
 * Es, en esencia, lo que hace el ApplicationContext de Spring
 * reducido a lo imprescindible.
 */
public class ContenedorSimple {

    /** Tipos registrados como disponibles. */
    private final Set<Class<?>> registrados = new LinkedHashSet<>();

    /** Instancias ya creadas: cada componente es un singleton. */
    private final Map<Class<?>, Object> instancias = new LinkedHashMap<>();

    /** Tipos que se estan creando ahora mismo: sirve para detectar ciclos. */
    private final Deque<Class<?>> enConstruccion = new ArrayDeque<>();

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

    public ContenedorSimple registrar(Class<?>... clases) {
        for (Class<?> clase : clases) {
            if (!clase.isAnnotationPresent(Componente.class)) {
                throw new IllegalArgumentException(
                        clase.getSimpleName() + " no está anotada con @Componente");
            }
            registrados.add(clase);
        }
        return this;
    }

    /** Registra una instancia ya construida (para configuracion, valores, etc.). */
    public <T> ContenedorSimple registrarInstancia(Class<T> tipo, T instancia) {
        instancias.put(tipo, instancia);
        registrados.add(tipo);
        return this;
    }

    @SuppressWarnings("unchecked")
    public <T> T obtener(Class<T> tipo) {
        // Cast seguro: solo guardamos instancias del tipo con el que se indexan
        return (T) resolver(tipo);
    }

    public void listar() {
        System.out.println("Componentes instanciados (" + instancias.size() + "):");
        instancias.forEach((tipo, obj) ->
                System.out.printf("  %-24s -> %s%n", tipo.getSimpleName(), obj));
    }

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

    private Object resolver(Class<?> tipo) {

        // 1. ¿Ya existe? Singleton.
        Object existente = instancias.get(tipo);
        if (existente != null) {
            return existente;
        }

        // 2. Buscar una implementacion registrada compatible
        Class<?> implementacion = buscarImplementacion(tipo);

        // 3. Detectar ciclos ANTES de entrar en recursion
        if (enConstruccion.contains(implementacion)) {
            List<String> ciclo = new ArrayList<>();
            for (Class<?> c : enConstruccion) {
                ciclo.add(0, c.getSimpleName());
            }
            ciclo.add(implementacion.getSimpleName());
            throw new IllegalStateException("Dependencia circular: " + String.join(" -> ", ciclo));
        }

        enConstruccion.push(implementacion);
        try {
            Object instancia = construir(implementacion);
            inyectarCampos(instancia);
            instancias.put(tipo, instancia);
            if (tipo != implementacion) {
                instancias.put(implementacion, instancia);
            }
            return instancia;
        } finally {
            enConstruccion.pop();
        }
    }

    /** Si piden una interfaz, busca la unica implementacion registrada. */
    private Class<?> buscarImplementacion(Class<?> tipo) {
        if (registrados.contains(tipo) && !tipo.isInterface()) {
            return tipo;
        }
        List<Class<?>> candidatos = new ArrayList<>();
        for (Class<?> c : registrados) {
            if (tipo.isAssignableFrom(c) && !c.isInterface()
                    && !Modifier.isAbstract(c.getModifiers())) {
                candidatos.add(c);
            }
        }
        if (candidatos.isEmpty()) {
            throw new IllegalStateException(
                    "No hay ningún componente registrado que satisfaga " + tipo.getSimpleName());
        }
        if (candidatos.size() > 1) {
            throw new IllegalStateException("Hay " + candidatos.size()
                    + " candidatos para " + tipo.getSimpleName() + ": " + candidatos);
        }
        return candidatos.get(0);
    }

    /** Instancia resolviendo recursivamente los parametros del constructor. */
    private Object construir(Class<?> clase) {

        Constructor<?> elegido = elegirConstructor(clase);
        elegido.setAccessible(true);

        Class<?>[] tiposParametro = elegido.getParameterTypes();
        Object[] argumentos = new Object[tiposParametro.length];

        for (int i = 0; i < tiposParametro.length; i++) {
            argumentos[i] = resolver(tiposParametro[i]);      // RECURSION
        }

        try {
            return elegido.newInstance(argumentos);
        } catch (InvocationTargetException e) {
            throw new IllegalStateException(
                    "El constructor de " + clase.getSimpleName() + " lanzó una excepción",
                    e.getCause());                            // la CAUSA, no el envoltorio
        } catch (ReflectiveOperationException e) {
            throw new IllegalStateException("No se pudo instanciar " + clase.getSimpleName(), e);
        }
    }

    private Constructor<?> elegirConstructor(Class<?> clase) {
        Constructor<?> sinArgumentos = null;

        for (Constructor<?> c : clase.getDeclaredConstructors()) {
            if (c.isAnnotationPresent(Inyectar.class)) {
                return c;                                     // prioridad al anotado
            }
            if (c.getParameterCount() == 0) {
                sinArgumentos = c;
            }
        }
        if (sinArgumentos != null) {
            return sinArgumentos;
        }
        // Convencion: si solo hay uno, se usa (como hace Spring desde 4.3)
        Constructor<?>[] todos = clase.getDeclaredConstructors();
        if (todos.length == 1) {
            return todos[0];
        }
        throw new IllegalStateException(clase.getSimpleName()
                + " tiene varios constructores y ninguno lleva @Inyectar");
    }

    /** Inyeccion por campo, DESPUES de construir. */
    private void inyectarCampos(Object instancia) {
        for (Class<?> c = instancia.getClass(); c != null && c != Object.class; c = c.getSuperclass()) {
            for (Field campo : c.getDeclaredFields()) {
                if (!campo.isAnnotationPresent(Inyectar.class)) {
                    continue;
                }
                campo.setAccessible(true);
                try {
                    campo.set(instancia, resolver(campo.getType()));
                } catch (IllegalAccessException e) {
                    throw new IllegalStateException(
                            "No se pudo inyectar el campo " + campo.getName(), e);
                }
            }
        }
    }
}

@Componente
public class CalculadoraMultas {
    public double calcular(int diasDeRetraso) { return diasDeRetraso * 0.25; }
    @Override public String toString() { return "[email protected]€/día"; }
}

@Componente
public class RepositorioMateriales extends Repositorio<Material> {
    public RepositorioMateriales() { super("catálogo"); }
}

@Componente
public class RepositorioPrestamos extends Repositorio<Prestamo> {
    public RepositorioPrestamos() { super("préstamos"); }
}

@Componente
public class GestorPrestamos implements ServicioPrestamos {

    private final RepositorioMateriales catalogo;
    private final RepositorioPrestamos prestamos;

    @Inyectar                                  // el contenedor usara ESTE constructor
    public GestorPrestamos(RepositorioMateriales catalogo, RepositorioPrestamos prestamos) {
        this.catalogo = catalogo;
        this.prestamos = prestamos;
    }

    @Inyectar                                  // inyeccion por campo
    private CalculadoraMultas calculadora;

    @Override public String toString() {
        return "GestorPrestamos[catálogo=" + catalogo + ", multas=" + calculadora + "]";
    }
}

public class ArranqueConContenedor {

    public static void main(String[] args) {

        ContenedorSimple contenedor = new ContenedorSimple()
                .registrar(GestorPrestamos.class,
                           RepositorioMateriales.class,
                           RepositorioPrestamos.class,
                           CalculadoraMultas.class);

        // NI UN SOLO new: el contenedor resuelve todo el grafo
        ServicioPrestamos servicio = contenedor.obtener(ServicioPrestamos.class);

        System.out.println("Obtenido: " + servicio);
        System.out.println();
        contenedor.listar();

        // Singleton: dos peticiones dan el MISMO objeto
        System.out.println();
        System.out.println("¿Singleton? "
                + (contenedor.obtener(CalculadoraMultas.class)
                   == contenedor.obtener(CalculadoraMultas.class)));
    }
}

Obtenido: GestorPrestamos[catálogo=Repositorio[catálogo, 0 entidades], [email protected]€/día]

Componentes instanciados (5):
  RepositorioMateriales    -> Repositorio[catálogo, 0 entidades]
  RepositorioPrestamos     -> Repositorio[préstamos, 0 entidades]
  CalculadoraMultas        -> [email protected]€/día
  GestorPrestamos          -> GestorPrestamos[...]
  ServicioPrestamos        -> GestorPrestamos[...]

¿Singleton? true

Exception in thread "main" java.lang.IllegalStateException:
    Dependencia circular: ServicioA -> ServicioB -> ServicioA

package com.nexussoftware.bibliotech.red;

import com.nexussoftware.bibliotech.anotaciones.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.
 * Sustituye a la logica de reintentos codificada a mano
 * dentro de ClienteHttpResistente (09-06).
 */
public final class ProxyReintentos implements InvocationHandler {

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

    private final Object objetivo;

    private ProxyReintentos(Object objetivo) {
        this.objetivo = objetivo;
    }

    @SuppressWarnings("unchecked")
    public static <T> T conReintentos(T objetivo, Class<T> interfaz) {
        return (T) Proxy.newProxyInstance(
                interfaz.getClassLoader(),
                new Class<?>[] { interfaz },
                new ProxyReintentos(objetivo));
    }

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

        Reintentable politica = resolverPolitica(metodo);

        if (politica == null || politica.intentos() <= 1) {
            return invocar(metodo, args);          // sin politica: una sola vez
        }

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

        for (int intento = 1; intento <= politica.intentos(); intento++) {
            try {
                Object resultado = invocar(metodo, args);

                if (intento > 1) {
                    int n = intento;
                    LOG.info(() -> String.format("%s() tuvo éxito en el intento %d",
                            metodo.getName(), n));
                }
                return resultado;

            } catch (Throwable fallo) {

                if (!esReintentable(fallo, politica)) {
                    LOG.fine(() -> "No se reintenta " + fallo.getClass().getSimpleName()
                            + ": no está en la política");
                    throw fallo;                    // error permanente: no insistir
                }

                fallosPrevios.add(fallo);

                if (intento == politica.intentos()) {
                    // Ultimo intento: adjuntar los anteriores como suprimidos (06-06)
                    for (int i = 0; i < fallosPrevios.size() - 1; i++) {
                        fallo.addSuppressed(fallosPrevios.get(i));
                    }
                    LOG.log(Level.SEVERE, () -> String.format(
                            "%s() agotó sus %d intentos", metodo.getName(), politica.intentos()));
                    throw fallo;
                }

                // Aleatorizacion (jitter): evita que N clientes reintenten a la vez (09-06)
                long conJitter = espera + ThreadLocalRandom.current().nextLong(espera / 2 + 1);

                int n = intento;
                LOG.warning(() -> String.format("%s() falló en el intento %d (%s); espera %d ms",
                        metodo.getName(), n, fallo.getClass().getSimpleName(), conJitter));

                dormir(conJitter);

                espera = (long) (espera * politica.factorDeCrecimiento());
            }
        }
        throw new IllegalStateException("inalcanzable");
    }

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

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

    private boolean esReintentable(Throwable fallo, Reintentable politica) {
        for (Class<? extends Exception> tipo : politica.excepciones()) {
            if (tipo.isInstance(fallo)) {       // isInstance: el instanceof reflexivo
                return true;
            }
        }
        return false;
    }

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

    /** Respeta la interrupcion: restaura la bandera y aborta (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.anotaciones.Reintentable;
import com.nexussoftware.bibliotech.red.ProxyReintentos;

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

public class PruebaProxyReintentos {

    interface ServicioMetadatos {
        String consultarPorIsbn(String isbn) throws IOException;
        String siempreFalla(String isbn) throws IOException;
    }

    /** Doble de prueba: falla las dos primeras veces y luego funciona. */
    static class ClienteInestable implements ServicioMetadatos {

        private int llamadas = 0;

        @Override
        @Reintentable(intentos = 4, esperaInicialMs = 100, factorDeCrecimiento = 2.0,
                      excepciones = { SocketTimeoutException.class })
        public String consultarPorIsbn(String isbn) throws IOException {
            llamadas++;
            if (llamadas < 3) {
                throw new SocketTimeoutException("tiempo agotado (llamada " + llamadas + ")");
            }
            return "{\"isbn\":\"" + isbn + "\",\"titulo\":\"Java Efectivo\"}";
        }

        @Override
        @Reintentable(intentos = 3, esperaInicialMs = 50, factorDeCrecimiento = 3.0,
                      excepciones = { IOException.class })
        public String siempreFalla(String isbn) throws IOException {
            throw new IOException("el servicio de metadatos no responde");
        }
    }

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

        ConfiguracionLog.inicializar();

        ServicioMetadatos servicio =
                ProxyReintentos.conReintentos(new ClienteInestable(), ServicioMetadatos.class);

        System.out.println("--- caso 1: se recupera al tercer intento ---");
        System.out.println("Resultado: " + servicio.consultarPorIsbn("978-0000000001"));

        System.out.println();
        System.out.println("--- caso 2: agota los intentos ---");
        try {
            servicio.siempreFalla("978-0000000002");
        } catch (IOException e) {
            System.out.println("Excepción final: " + e.getMessage());
            System.out.println("Fallos suprimidos: " + e.getSuppressed().length);
            for (Throwable s : e.getSuppressed()) {
                System.out.println("  suprimido: " + s.getMessage());
            }
        }
    }
}

--- caso 1: se recupera al tercer intento ---
[WARNING] consultarPorIsbn() falló en el intento 1 (SocketTimeoutException); espera 137 ms
[WARNING] consultarPorIsbn() falló en el intento 2 (SocketTimeoutException); espera 265 ms
[INFO]    consultarPorIsbn() tuvo éxito en el intento 3
Resultado: {"isbn":"978-0000000001","titulo":"Java Efectivo"}

--- caso 2: agota los intentos ---
[WARNING] siempreFalla() falló en el intento 1 (IOException); espera 71 ms
[WARNING] siempreFalla() falló en el intento 2 (IOException); espera 194 ms
[SEVERE]  siempreFalla() agotó sus 3 intentos
Excepción final: el servicio de metadatos no responde
Fallos suprimidos: 2
  suprimido: el servicio de metadatos no responde
  suprimido: el servicio de metadatos no responde