Lecciones

Cómo crear objetos y gestionar clases «sobre la marcha»: por qué Class.newInstance() está obsoleto, cómo usar correctamente getConstructor/ getDeclaredConstructor y Constructor.newInstance, invocar métodos con Method.invoke y leer/modificar campos con Field. Analizaremos las excepciones típicas ( ReflectiveOperationException y otras), las restricciones del sistema de módulos, prácticas útiles y una mini‑utilidad para la instanciación dinámica. Además, un esquema claro de todo el proceso.

En esta lección analizamos la práctica de la reflexión en Java: cómo, a través de Class, Field y Method, leer campos privados ( setAccessible( true)) y crear un serializador sencillo; cómo los contenedores DI inyectan dependencias por anotaciones ( @Inject, @Autowired) mediante constructores y campos; cómo los proxies dinámicos basados en Proxy y InvocationHandler interceptan llamadas; dónde se aplica en la práctica ( Spring, JUnit, Jackson) y qué limitaciones y errores aparecen.

Por qué las aplicaciones necesitan logs y por qué simplemente System.out.println no salva en producción. Veremos los niveles ERROR/ WARN/ INFO/ DEBUG/ TRACE, el sistema integrado java.util.logging y el archivo de configuración logging.properties, nos familiarizaremos con Log4j 2, Logback y la fachada SLF4J. Lo compararemos con la salida por consola, añadiremos dependencias y revisaremos errores típicos de configuración y uso.

Analizamos de qué se compone un buen mensaje de log (hora, nivel INFO/ ERROR, nombre del logger, texto, stack), cómo formatear correctamente las entradas con plantillas de SLF4J/Log4j2 ( "{}" en lugar de concatenación), cómo registrar excepciones ( logger.error(..., ex)), cuándo usar los niveles ERROR/ WARN/ INFO/ DEBUG/ TRACE, así como las mejores prácticas: sin datos sensibles, mensajes claros, IDs de correlación ( orderId, userId) y una configuración adecuada de log4j2.xml.

Cómo hacer que los logs sean fiables en multihilo y en la web: seguridad de hilos de las bibliotecas existentes ( Logback, Log4j 2, java.util.logging), contexto MDC con propagación de requestId, integración con filtros de Spring y manejadores de errores, diferencia respecto a System.out, matices de los pools de hilos y trazabilidad en microservicios (traceId, OpenTelemetry). Analizamos ejemplos prácticos y errores típicos, usamos SLF4J y Logger como campo static final.

Esta lección es una guía práctica sobre la monitorización de JVM: cómo leer métricas estándar mediante JMX y JConsole, cómo observar visualmente la memoria, los hilos y perfilar métodos en VisualVM (incluidos heap dump y thread dump), y también cómo grabar la «caja negra» con Java Flight Recorder y analizarla en JDK Mission Control. Mostraremos comandos de arranque ( -XX:StartFlightRecording), revisaremos escenarios típicos de análisis de GC/hilos y errores comunes.

Analizamos en qué se diferencia el perfilado del monitoreo, qué métricas son importantes (tiempo de ejecución de métodos, memoria, hilos, bloqueos) y qué herramientas usar: VisualVM, Java Flight Recorder, así como perfiladores comerciales. En la práctica investigamos una calculadora «lenta», aprendemos a encontrar «hot spots», analizar un heap dump y eliminar cuellos de botella mediante la sustitución de algoritmos, la reducción de asignaciones y el uso de caché. Terminamos con un esquema visual del proceso de optimización y con el análisis de errores habituales.

Adónde van las variables locales, los objetos y los metadatos de clases durante el proceso de la JVM: analizamos la pila de los hilos, el heap y la evolución de PermGen → MetaSpace. Hablaremos de cómo funciona GC, qué errores de memoria existen ( StackOverflowError, OutOfMemoryError) y cómo influyen las flags de arranque ( -Xss, -Xmx, -XX:MaxMetaspaceSize). Se incluyen esquemas, un diagrama Mermaid y un ejemplo funcional.

En esta lección explicamos cómo funciona el recolector de basura ( GC) en la JVM, en qué se diferencian los recolectores clásicos Serial/ Parallel/ CMS de los modernos G1, ZGC y Shenandoah, qué son las generaciones joven y vieja, por qué se producen las pausas Stop-the-World y cómo minimizarlas. En la práctica veremos cómo activar distintos GC mediante opciones ( -XX:+UseG1GC, -XX:+UseZGC, -XX:+UseShenandoahGC), ajustar las pausas ( -XX:MaxGCPauseMillis) y el tamaño del heap ( -Xms/ -Xmx), leer los logs ( -Xlog:gc*) y evitar errores típicos (por ejemplo, llamar a System.gc() de forma explícita).

De esta lección aprenderás dónde viven las variables locales (la pila del hilo) y en qué se diferencia del heap, por qué en Java sí son posibles las fugas de memoria a pesar del GC y cómo evitarlas. Veremos escenarios reales: colecciones static «eternas», listeners no desregistrados y cachés. Nos familiarizaremos con la familia de referencias: SoftReference, WeakReference, PhantomReference, así como con el contenedor WeakHashMap. Practicaremos cómo corregir fugas y comentaremos por qué la llamada a System.gc() — no es más que una sugerencia para la JVM, no una orden, y en qué puede terminar un OutOfMemoryError.

Guía práctica para diagnosticar problemas de memoria en la JVM: tomamos un volcado de heap ( heap dump) con la utilidad jmap, leemos resúmenes a través de -heap y -histo, exploramos la aplicación en jvisualvm (pestañas Monitor, Heap Dump, Threads, Profiler), resolvemos una fuga a modo de ejemplo y nos familiarizamos con Eclipse MAT y jconsole. Al final — errores frecuentes y consejos.

Análisis práctico de por qué una aplicación Java puede «perder» memoria y volverse lenta: listeners olvidados ( addActionListener/ removeActionListener), colecciones estáticas eternas, recursos sin cerrar (consejo: try-with-resources), clases anónimas/internas que retienen referencias y abuso de System.gc(). Aprenderemos a leer los registros del GC ( -Xlog:gc*, -XX:+PrintGCDetails), elegir el recolector, construir cachés con WeakHashMap, monitorizar ( jvisualvm, jconsole), analizar heap dumps y configurar correctamente -Xmx/ -Xms. Al final — ejemplos reales de fugas y su corrección.