Leçons

Comment créer des objets et manipuler des classes « à la volée » : pourquoi Class.newInstance() est obsolète, comment utiliser correctement getConstructor/ getDeclaredConstructor et Constructor.newInstance, appeler des méthodes via Method.invoke et lire/modifier des champs via Field. Nous analyserons les exceptions typiques ( ReflectiveOperationException et autres), les contraintes du système modulaire, des bonnes pratiques et une mini‑utilitaire pour l’instanciation dynamique. En bonus — un schéma clair de tout le processus.

Dans ce cours, nous abordons la pratique de la réflexion en Java : comment, via Class, Field et Method, lire des champs privés ( setAccessible( true)) et construire un sérialiseur simple ; comment les conteneurs DI injectent les dépendances à l’aide d’annotations ( @Inject, @Autowired) via les constructeurs et les champs ; comment des proxies dynamiques basés sur Proxy et InvocationHandler interceptent les appels ; où cela s’utilise en pratique ( Spring, JUnit, Jackson) et quelles limites et erreurs apparaissent.

Pourquoi les applications ont besoin de journaux, et pourquoi un simple System.out.println ne suffit pas en production. Nous passerons en revue les niveaux ERROR/ WARN/ INFO/ DEBUG/ TRACE, la pile intégrée de java.util.logging et le fichier de configuration logging.properties, nous ferons connaissance avec Log4j 2, Logback et la façade SLF4J. Nous comparerons avec la sortie console, ajouterons les dépendances et analyserons les erreurs typiques de configuration et d’utilisation.

Nous analysons la composition d’un bon message de log (horodatage, niveau INFO/ ERROR, nom du logger, texte, stack, pile), la bonne façon de formater les entrées avec les modèles SLF4J/Log4j2 ( "{}" au lieu de la concaténation), comment journaliser les exceptions ( logger.error(..., ex)), quand utiliser les niveaux ERROR/ WARN/ INFO/ DEBUG/ TRACE, ainsi que les bonnes pratiques : pas de données sensibles, messages clairs, IDs de corrélation ( orderId, userId) et une configuration soignée de log4j2.xml.

Comment rendre les logs fiables en environnement multithread et sur le web : sécurité des threads des bibliothèques prêtes à l’emploi ( Logback, Log4j 2, java.util.logging), contexte MDC avec propagation de requestId, intégration avec les filtres Spring et les gestionnaires d’erreurs, différence par rapport à System.out, subtilités des pools de threads et traçage dans les microservices (traceId, OpenTelemetry). Nous analysons des exemples pratiques et des erreurs typiques, en utilisant SLF4J et Logger comme champ static final.

Ce cours est un guide pratique de la surveillance de la JVM : comment lire les métriques standard via JMX et JConsole, comment observer visuellement la mémoire, les threads et profiler les méthodes dans VisualVM (y compris le heap dump et le thread dump), ainsi que comment enregistrer la « boîte noire » avec Java Flight Recorder et l’analyser dans JDK Mission Control. Nous montrerons les commandes de démarrage ( -XX:StartFlightRecording), passerons en revue des scénarios types d’analyse GC/threads et les erreurs courantes.

Nous expliquons en quoi le profilage diffère du monitoring, quelles métriques sont importantes (temps d’exécution des méthodes, mémoire, threads, verrous) et quels outils utiliser: VisualVM, Java Flight Recorder, ainsi que des profileurs commerciaux. En pratique, nous étudions un « calculateur lent », apprenons à trouver les « hot spots », à analyser un heap dump et à éliminer les goulots d’étranglement en remplaçant des algorithmes, en réduisant les allocations et en mettant en cache. Nous concluons par un schéma visuel du processus d’optimisation et un examen des erreurs typiques.

Où vont les variables locales, les objets et les métadonnées de classes dans un processus JVM : nous passons en revue la pile des threads, le tas et l’évolution de PermGen → MetaSpace. Nous parlerons du fonctionnement du GC, des erreurs mémoire possibles ( StackOverflowError, OutOfMemoryError) et de l’influence des options de lancement ( -Xss, -Xmx, -XX:MaxMetaspaceSize). Schémas, diagramme Mermaid et exemple fonctionnel inclus.

Dans ce cours, nous expliquons le fonctionnement du ramasse-miettes ( GC) dans la JVM, en quoi les collecteurs classiques Serial/ Parallel/ CMS diffèrent des modernes G1, ZGC et Shenandoah, ce que sont les jeunes et vieilles générations, pourquoi des pauses Stop-the-World se produisent et comment les minimiser. En pratique, nous verrons comment activer différents GC via les options ( -XX:+UseG1GC, -XX:+UseZGC, -XX:+UseShenandoahGC), régler les pauses ( -XX:MaxGCPauseMillis) et la taille du tas ( -Xms/ -Xmx), lire les logs ( -Xlog:gc*) et éviter les erreurs courantes (par exemple, l’appel forcé à System.gc()).

Dans ce cours, vous découvrirez où « vivent » les variables locales (pile du thread) et en quoi elle diffère du tas, pourquoi les fuites de mémoire sont tout de même possibles en Java malgré le GC, et comment les éviter. Nous analyserons des scénarios réels : collections static « éternelles », écouteurs non désinscrits et caches. Nous ferons connaissance avec la famille des références : SoftReference, WeakReference, PhantomReference, ainsi qu’avec le conteneur WeakHashMap. Nous nous exercerons à corriger des fuites et discuterons pourquoi l’appel à System.gc() — ce n’est qu’une suggestion à la JVM, pas un ordre — et ce qu’un OutOfMemoryError peut entraîner.

Guide pratique pour diagnostiquer les problèmes de mémoire dans la JVM: réaliser un instantané du tas ( heap dump) avec l’utilitaire jmap, lire les résumés via -heap et -histo, explorer l’application dans jvisualvm (onglets Monitor, Heap Dump, Threads, Profiler), analyser une fuite sur un exemple et faire connaissance avec Eclipse MAT et jconsole. Pour finir — erreurs fréquentes et conseils.

Analyse pratique des raisons pour lesquelles une application Java peut « fuir » de la mémoire et ralentir : écouteurs oubliés ( addActionListener/ removeActionListener), collections statiques qui vivent indéfiniment, ressources non fermées (conseil : try-with-resources), classes anonymes/internes retenant des références, et abus de System.gc(). Nous apprendrons à lire les logs GC ( -Xlog:gc*, -XX:+PrintGCDetails), à choisir le collecteur, à construire des caches avec WeakHashMap, à surveiller ( jvisualvm, jconsole), à analyser des heap dumps, et à configurer correctement -Xmx/ -Xms. À la fin — des exemples concrets de fuites et leurs corrections.