Lecciones

Analizamos qué es el archivo module-info.java, dónde se encuentra en el proyecto y cómo declarar un módulo mediante la palabra clave module. Aprendemos a exportar la API con exports, añadir dependencias con requires, y también vemos directivas adicionales ( opens, uses, provides ... with). En la lección: ejemplos, reglas de nomenclatura de módulos, análisis práctico de la estructura del proyecto y errores típicos en la construcción modular.

Cómo Java 9+ añadió encapsulación modular por encima de clases y paquetes: incluso las clases public permanecen ocultas mientras el paquete no se abra explícitamente mediante exports en module-info.java. Vemos cómo declarar dependencias con requires, cómo restringir la visibilidad con exports to, en qué se diferencia el nivel module de private/ public, y qué errores de compilación (por ejemplo, «package ... is not visible», «cannot access ...») indican que olvidaste añadir exports o requires.

Guía práctica sobre arquitectura modular en Java: cuándo y por qué dividir el código en módulos, esquemas típicos (arquitectura Onion, separación en api/ impl, módulos de pruebas), configuración de dependencias mediante module-info.java y las palabras clave requires/ exports, ejemplos funcionales de un proyecto con 3 módulos, integración con Maven/ Gradle e IntelliJ IDEA, así como un análisis de errores habituales (dependencias cíclicas, paquetes no exportados, --module-path incorrecto).

Cómo compilar un proyecto modular en Java: la diferencia entre classpath y module-path, cuándo usar la opción --module-path, cómo configurar una estructura multimódulo en Maven y Gradle, y cómo ejecutarlo todo desde IntelliJ IDEA. Mostraremos la estructura de módulos con module-info.java, las dependencias mediante requires/ exports, la configuración de plugins y los errores frecuentes en la compilación.

Analizamos cómo lanzar comandos y utilidades externas desde Java con la clase ProcessBuilder: en qué es mejor que Runtime. getRuntime(). exec(), cómo configurar el directorio de trabajo mediante directory(), las variables de entorno con environment(), y gestionar el proceso con start(), waitFor(), y los flujos getInputStream()/ getErrorStream()/ getOutputStream(). Comentaremos la multiplataforma ( cmd.exe/ ls), el trabajo con stdout/ stderr y los errores típicos.

Práctica de trabajo con procesos externos en Java: cómo leer stdout a través de Process.getInputStream(), capturar errores desde stderr mediante Process.getErrorStream(), escribir en stdin con Process.getOutputStream(), así como utilizar los métodos prácticos inputReader()/ errorReader()/ outputWriter(). Analizaremos particularidades de comandos como java -version, la lectura en paralelo de flujos para evitar el interbloqueo ( deadlock), el trabajo con codificaciones ( "UTF-8") y un pequeño puente con scripts de Python.

Práctica de gestión de procesos externos desde Java: esperamos su finalización con waitFor() (incluidos los tiempos de espera), leemos el código de salida, los detenemos correctamente con destroy()/ destroyForcibly(), evitamos bloqueos y procesos «zombi», sin olvidar los flujos de salida y las excepciones. Analizamos matices multiplataforma y errores típicos.

En esta lección veremos cómo organizar desde Java un «diálogo en vivo» con programas externos: escribir en stdin, leer de stdout y stderr, evitar bloqueos mutuos ( deadlock), procesar la salida en paralelo con ExecutorService, cerrar correctamente los flujos y gestionar el ciclo de vida de Process mediante ProcessBuilder. Veremos ejemplos con un script interactivo en Python y la utilidad bc, y también analizaremos las trampas de la bufferización y la necesidad de flush().

Guía práctica para trabajar de forma robusta con procesos externos en Java: cómo evitar bloqueos por flujos stdout/ stderr no leídos, configurar correctamente las codificaciones de salida (por ejemplo, UTF-8, CP866), tener en cuenta las diferencias entre sistemas en los comandos ( ls vs dir), manejar permisos y códigos de salida mediante process.exitValue(), cerrar recursos sin fugas y evitar interbloqueos interactivos. Tratamos el uso correcto de ProcessBuilder, la lectura paralela de flujos (hilos/ ExecutorService), la finalización correcta mediante process.destroy(), así como rutas portables con File.separator.

Veremos qué es la reflexión en Java y para qué la necesitan los frameworks y las herramientas, cómo funciona el objeto Class —el corazón de la reflexión— y de qué maneras obtenerlo: mediante .class, getClass() y Class.forName(). Hablaremos de cuándo conviene usar la reflexión y cuándo es mejor prescindir de ella, veremos ejemplos de obtención de metadatos (nombre, paquete, superclase, interfaces), analizaremos una miniutilidad «¿Qué clase es?» y los errores típicos ( ClassNotFoundException, rendimiento, seguridad).

En la lección analizamos la reflexión en Java: cómo, mediante la Class-API, obtener información sobre los campos ( getFields()/ getDeclaredFields()), los métodos ( getMethods()/ getDeclaredMethods()), los constesctores ( getConstesctors()/ getDeclaredConstesctors()) y las anotaciones ( getAnnotations()). Veremos los modificadores a través de Modifier ( public, private, protected, static, final), explicaremos las diferencias entre «public y declared», constesiremos una miniutilidad de inspección de clases y veremos un esquema visual.

En la lección analizamos los riesgos y las limitaciones de la reflexión: cómo saltarse la encapsulación mediante setAccessible( true), los intentos de cambiar campos final y por qué esto es peligroso debido a las optimizaciones de la JVM; el destino de SecurityManager y cómo el sistema de módulos (Java 9+) conduce a InaccessibleObjectException. Hablaremos de la pérdida de rendimiento y de la seguridad de tipos, de alternativas modernas ( record, sealed, pattern matching, APT, DI) y de buenas prácticas. Al final — un ejemplo práctico con el parámetro de la JVM --add-opens.