Lezioni

Vediamo che cos’è il file module-info.java, dove si trova nel progetto e come dichiarare un modulo con la parola chiave module. Impariamo a esportare le API tramite exports, collegare le dipendenze con requires e diamo anche un’occhiata alle direttive aggiuntive ( opens, uses, provides ... with). Nella lezione — esempi, regole di denominazione dei moduli, analisi pratica della struttura del progetto ed errori tipici nella build modulare.

Come Java 9+ ha aggiunto l’incapsulamento modulare sopra classi e pacchetti: persino le classi public sono nascoste finché il pacchetto non viene esplicitamente aperto tramite exports in module-info.java. Vediamo come dichiarare dipendenze con requires, come limitare la visibilità con exports to, in cosa il livello module differisce da private/ public e quali errori di compilazione (per esempio, « package ... is not visible », « cannot access ... ») indicano che hai dimenticato exports o requires.

Guida pratica all’architettura modulare in Java: quando e perché suddividere il codice in moduli, schemi tipici (architettura a cipolla, separazione in api/ impl, moduli di test), configurazione delle dipendenze tramite module-info.java e le parole chiave requires/ exports, esempi funzionanti di un progetto in 3 moduli, integrazione con Maven/ Gradle e IntelliJ IDEA, oltre all’analisi degli errori più comuni (dipendenze cicliche, pacchetti non esportati, --module-path errato).

Come costruire un progetto modulare in Java: la differenza tra classpath e module-path, quando usare il flag --module-path, come configurare una struttura multi-modulo in Maven e Gradle, e come avviare tutto da IntelliJ IDEA. Mostreremo la struttura dei moduli con module-info.java, le dipendenze tramite requires/ exports, la configurazione dei plugin e gli errori frequenti durante il build.

Vediamo come avviare da Java comandi e utility esterni con la classe ProcessBuilder: perché è migliore di Runtime. getRuntime(). exec(), come configurare la directory di lavoro tramite directory(), le variabili d'ambiente tramite environment(), e come gestire il processo tramite start(), waitFor(), i flussi getInputStream()/ getErrorStream()/ getOutputStream(). Discuteremo la portabilità tra piattaforme ( cmd.exe/ ls), il lavoro con stdout/ stderr e gli errori tipici.

Pratica con i processi esterni in Java: come leggere stdout tramite Process.getInputStream(), intercettare gli errori da stderr tramite Process.getErrorStream(), scrivere su stdin con Process.getOutputStream(), e usare anche i pratici metodi inputReader()/ errorReader()/ outputWriter(). Vedremo le particolarità di comandi come java -version, la lettura parallela dei flussi per evitare il deadlock, la gestione delle codifiche ( "UTF-8") e un piccolo bridge con script Python.

Pratica di gestione dei processi esterni da Java: attendiamo la terminazione con waitFor() (inclusi i timeout), leggiamo il codice di uscita, arrestiamo correttamente con destroy()/ destroyForcibly(), preveniamo blocchi e processi «zombie», senza dimenticare i flussi di output e le eccezioni. Analizziamo gli aspetti multipiattaforma e gli errori tipici.

In questa lezione vedremo come, da Java, organizzare un dialogo “in tempo reale” con programmi esterni: scrivere su stdin, leggere da stdout e stderr, evitare blocchi reciproci ( deadlock), elaborare in parallelo l'output con ExecutorService, chiudere correttamente i flussi e gestire il ciclo di vita di Process tramite ProcessBuilder. Vedremo esempi con uno script interattivo in Python e l'utility bc, e analizzeremo anche le insidie del buffering e la necessità di flush().

Guida pratica per lavorare in modo robusto con processi esterni in Java: come evitare blocchi dovuti a stream stdout/ stderr non letti, configurare correttamente le codifiche di output (ad esempio, UTF-8, CP866), tenere conto delle differenze cross‑platform dei comandi ( ls vs dir), gestire i permessi e i codici di uscita tramite process.exitValue(), chiudere le risorse senza perdite ed evitare deadlock nell’interazione interattiva. Esaminiamo l’uso corretto di ProcessBuilder, la lettura parallela degli stream (thread/ ExecutorService), la terminazione corretta tramite process.destroy(), nonché percorsi portabili con File.separator.

Analizzeremo che cos’è la reflection in Java e a cosa serve a framework e strumenti, come funziona l’oggetto Class — il cuore della reflection — e in quali modi ottenerlo: tramite .class, getClass() e Class.forName(). Parleremo di quando conviene usare la reflection e quando è meglio farne a meno, vedremo esempi di ottenimento di metadati (nome, package, superclasse, interfacce), analizzeremo una mini‑utility «Che classe è?» e gli errori tipici ( ClassNotFoundException, prestazioni, sicurezza).

In questa lezione analizziamo la riflessione in Java: come, tramite l’API di Class, ottenere informazioni sui campi ( getFields()/ getDeclaredFields()), sui metodi ( getMethods()/ getDeclaredMethods()), sui costruttori ( getConstructors()/ getDeclaredConstructors()) e sulle annotazioni ( getAnnotations()). Scopriremo i modificatori tramite Modifier ( public, private, protected, static, final), analizzeremo le differenze «public contro declared», assembleremo una mini‑utility ispettore di classi e vedremo uno schema visivo.

Nella lezione analizziamo rischi e limitazioni della reflection: l’aggiramento dell’incapsulamento tramite setAccessible( true), i tentativi di modificare campi final e perché ciò è pericoloso a causa delle ottimizzazioni della JVM; il destino di SecurityManager e come il sistema modulare (Java 9+) porta a InaccessibleObjectException. Parleremo della perdita di prestazioni e della sicurezza dei tipi, delle alternative moderne ( record, sealed, pattern matching, APT, DI) e delle best practice. Alla fine — un esempio pratico con il parametro JVM --add-opens.