
Formation Java
Maîtriser le développement Java moderne : syntaxe Java 21+, POO, collections et streams, Spring Boot, tests automatisés, performance JVM et déploiement production.
Format
Intra-entreprise
Durée recommandée
≈ 28 à 42 heures
Démarrage
Sous 15 jours
Sur-mesure
Programme co-construit avec le formateur
Point d'entrée commun aux développeurs venus de Python, JavaScript, C# ou Go et à ceux qui montent vers Java 21 : la JVM, SDKMAN et un projet Maven ou Gradle. Records, sealed classes, pattern matching sur switch, Streams API et Optional installent ensuite les réflexes du Java moderne, ceux qu'il faut avoir pour relire ce que Claude Code, Codex ou GitHub Copilot proposent, avant la concurrence avec CompletableFuture et les virtual threads. Les travaux pratiques Spring se font sur Spring Boot 4 et aboutissent à une API REST avec Spring Data JPA, Spring Security, JWT et OAuth2, documentée par Springdoc OpenAPI. Les tests passent par JUnit 6, Mockito, MockMvc et Testcontainers, puis par les tests de caractérisation, qui figent le comportement d'une application avant qu'on y touche. Ils servent de filet au module de modernisation : Java 8 ou 11 vers 21, Spring Boot 2 vers 3 puis 4, javax vers jakarta. Les recettes OpenRewrite font la partie mécanique, qui ressort identique à chaque exécution, et l'agent traite ce qu'aucune recette ne couvre, diff relu à chaque étape. Reste l'exploitation, avec un profilage sous JFR, le choix du GC entre G1 et ZGC, la conteneurisation et une supervision sous Micrometer et Prometheus.
Pour qui ?
- ›Développeurs souhaitant apprendre Java ou monter en compétences vers Java 21+
- ›Développeurs venant d'autres langages (Python, JS, C#, Go) voulant maîtriser Java
- ›Lead techs et architectes industrialisant leurs équipes Java
- ›Profils Backend ou Full-Stack travaillant sur des projets Spring et Spring Boot
- ›Équipes qui maintiennent une application Java 8 ou 11 sous Spring Boot 2 et préparent sa migration avec un agent IA
- ›Jeunes diplômés et profils en reconversion se professionnalisant sur Java
Prérequis
- ›Avoir une expérience préalable en programmation (au moins un autre langage : Python, JavaScript, C, C#, PHP). Notions de POO appréciées. Aucun prérequis Java spécifique pour la partie initiation. Disposer d'une machine de développement (JDK 21 ou plus récent installé).
Objectifs pédagogiques
- ›Comprendre l'architecture JVM et maîtriser la syntaxe Java moderne
- ›Appliquer les principes POO et les design patterns essentiels
- ›Exploiter les collections, streams et la programmation fonctionnelle
- ›Gérer exceptions, I/O et concurrence (threads, virtual threads)
- ›Construire une API REST production-ready avec Spring Boot
- ›Mettre en place des tests automatisés et figer par des tests de caractérisation le comportement d'un code existant
- ›Moderniser une application Java existante en répartissant le travail entre recettes OpenRewrite et agent IA
- ›Optimiser les performances et déployer en production
Programme détaillé
8 modules, construits autour de vos cas réels.
Durée recommandée : ≈ 28 à 42 heures, modulable selon le rythme du groupe et vos contraintes intra-entreprise.
01Fondamentaux Java, écosystème JVM et syntaxe moderne
Chapitres- Comprendre l'architecture JVM, la distinction JRE/JDK et le rôle du bytecode
- Installer et gérer plusieurs JDK avec SDKMAN, choisir une distribution OpenJDK (Temurin, Corretto, Zulu) et configurer l'IDE (IntelliJ IDEA, Eclipse, VS Code) et son débogueur
- Structurer un projet Maven ou Gradle et fixer la version cible avec l'option --release du compilateur, pour qu'un agent ne glisse pas une API de Java 21 dans un module livré en Java 11
- Situer le cycle des releases LTS (Java 21, Java 25), GraalVM et l'interopérabilité avec Kotlin et Scala
- Maîtriser les types primitifs, le typage statique, l'inférence avec var et la portée des variables
- Exploiter les switch expressions, les records, les sealed classes et le pattern matching sur switch finalisé en Java 21
- Manipuler chaînes, text blocks et formatage, et appliquer immuabilité et conventions de nommage
- Repérer dans le code proposé par un agent les idiomes d'un Java plus ancien (classe anonyme là où une lambda suffit, getters écrits à la main au lieu d'un record, null renvoyé au lieu d'un Optional) et demander la version moderne
02Programmation orientée objet en Java
Chapitres- Appliquer l'encapsulation, l'héritage, le polymorphisme et l'abstraction
- Distinguer interfaces, classes abstraites et méthodes par défaut
- Implémenter les design patterns courants (Factory, Singleton, Observer, Strategy)
- Maîtriser les generics, les bounded types et le code type-safe
- Redéfinir equals, hashCode et toString selon les contrats du langage
- Organiser le code en packages et gérer la visibilité avec le système de modules
03Collections, Streams et programmation fonctionnelle
Chapitres- Maîtriser les collections (List, Set, Map) et choisir la bonne implémentation
- Exploiter la Streams API pour des traitements de données déclaratifs
- Écrire des lambdas et utiliser les method references
- Gérer la nullabilité avec Optional plutôt qu'avec des null bruts
- Construire des agrégations avec les Collectors et les opérations terminales
- Identifier les pièges de performance (autoboxing, parallel streams mal employés)
04Exceptions, entrées-sorties et concurrence
Chapitres- Gérer les exceptions checked et unchecked avec try-with-resources et multi-catch
- Travailler avec les I/O modernes (NIO.2, Path, Files, FileChannel)
- Comprendre le modèle de threads et les primitives de synchronisation (synchronized, Lock, volatile)
- Orchestrer des traitements asynchrones avec ExecutorService et CompletableFuture
- Exploiter les virtual threads, en standard depuis Java 21, et le pattern Fork/Join
05Spring Boot et développement d'une API REST
Chapitres- Initialiser un projet Spring Boot 4 avec Spring Initializr et comprendre l'auto-configuration
- Construire controllers REST, services et repositories avec Spring Data JPA
- Mapper les entités, gérer les transactions et les relations entre tables
- Sécuriser l'API avec Spring Security, JWT et OAuth2, et relire la SecurityFilterChain qu'un agent propose (CSRF coupé sans raison, permitAll posé trop large)
- Externaliser la configuration par profils et variables d'environnement
- Documenter l'API avec Springdoc OpenAPI et exposer une interface Swagger
06Tests automatisés et filet de caractérisation
Chapitres- Écrire des tests unitaires avec JUnit 6 et isoler les dépendances avec Mockito
- Tester une API Spring Boot avec MockMvc et @SpringBootTest, et des intégrations réelles avec Testcontainers (PostgreSQL, Redis, Kafka)
- Poser des tests de caractérisation avant de toucher au code : figer ce que l'application fait aujourd'hui, bugs compris, sur les points d'entrée que la migration va traverser (contrôleurs, batchs, exports)
- Comparer des sorties complètes (JSON, XML, fichier d'export) avec ApprovalTests plutôt qu'en alignant cent assertions, et relire chaque fichier approuvé avant de le committer
- Faire écrire le premier jet de ces tests par un agent à partir de requêtes réelles rejouées, avec une consigne ferme : il fige le comportement, il ne corrige pas le bug qu'il croit voir
- Repérer avec JaCoCo les classes que la migration touchera et qu'aucun test n'exerce, et analyser le code avec SonarQube et SpotBugs
- Automatiser la qualité dans une chaîne CI (GitHub Actions, GitLab CI, Jenkins)
07Moderniser un legacy Java avec OpenRewrite et un agent
Chapitres- Dresser l'état des lieux avant tout changement : jdeps --jdk-internals pour les API internes du JDK, jdeprscan --for-removal pour les API promises au retrait, et dates de fin de support (Spring Boot 3.5 ne reçoit plus de correctif open source depuis le 30 juin 2026)
- Comprendre ce qui sépare une recette OpenRewrite d'une transformation par agent : la recette opère sur un arbre sémantique sans perte (LST) qui connaît les types et conserve la mise en forme, l'agent réécrit à partir du texte qu'il lit et ne rend pas forcément deux fois le même diff
- Enchaîner les recettes officielles une marche à la fois : UpgradeToJava21 ou UpgradeToJava25, UpgradeSpringBoot_3_0 qui embarque déjà le passage à Java 17, puis UpgradeSpringBoot_4_0 qui chaîne Spring Framework 7, Spring Security 7, Hibernate 7.1 et Testcontainers 2
- Basculer de javax vers jakarta avec la recette JavaxMigrationToJakarta, qui couvre le code Java et une partie des descripteurs XML, puis chercher à la main ce qu'elle laisse passer : noms de packages écrits en chaîne de caractères, descripteurs et fichiers d'amorçage qu'elle ne réécrit pas, bibliothèques restées sans version jakarta
- Lancer rewrite:dryRun, lire le patch produit dans target/rewrite/rewrite.patch avant tout rewrite:run, et déclarer le dépôt authentifié du Code Genome Project, où les recettes sont désormais publiées à la place de Maven Central
- Confier à l'agent ce qui reste après la recette : erreurs de compilation, API retirées sans remplaçant mécanique, injection cassée faute de l'option -parameters depuis Spring Framework 6.1, propriétés renommées que signale spring-boot-properties-migrator
- Séparer l'historique en commits distincts, celui de la recette relu par échantillon puisqu'il se rejoue à l'identique, ceux de l'agent relus ligne à ligne, avec les tests de caractérisation au vert entre chaque marche
- Comparer les outils de transformation pilotés par agent : GitHub Copilot modernization (Java 8 à 25, Maven et Gradle, build, contrôle des CVE et tests), la transformation d'Amazon Q Developer (projets Maven, Java 8 ou 11 vers 17 ou 21), le serveur MCP de Moderne qui ouvre les recettes à Claude Code ou Cursor
08Performance, déploiement et supervision
Chapitres- Profiler une application avec JFR, Async Profiler et VisualVM
- Tuner la JVM (dimensionnement du heap, choix du GC G1 ou ZGC) et faire le tri, après une montée de version, des options héritées d'un ancien JDK devenues obsolètes ou contre-productives
- Containeriser l'application avec Docker, jlink et GraalVM native-image
- Déployer sur Kubernetes ou une plateforme PaaS
- Superviser en production avec Micrometer, Prometheus, Grafana et Sentry
Moyens & supports pédagogiques
- Accueil des stagiaires
- Supports de formation projets
- Apports théoriques et pratiques
- Études de cas concrets
- Auto-positionnement
- Accès en ligne aux ressources
Évaluation & suivi des acquis
Feuille de présence
Émargement des stagiaires en présentiel ou à distance, via support papier ou signature électronique.
Émargement sécurisé
Signatures électroniques collectées en ligne et conservées dans un coffre-fort numérique sécurisé par Dendreo.
Auto-positionnement
Évaluation du niveau des stagiaires en début et en fin de formation pour mesurer la progression.
Évaluations pédagogiques
Validation des acquis par des questions orales ou écrites tout au long de la formation.
Mises en situation
Exercices pratiques et cas concrets pour ancrer les compétences dans la réalité métier.
Attestation de fin de formation
Remise d'une attestation officielle à l'issue de la formation.
Délai d’accès
Sous 15 jours après validation du devis
Accessibilité PSH
Adaptations possibles en situation de handicap. En savoir plus
Questions fréquentes
Ce que les entreprises demandent avant de se lancer.
Sur quelle version de Java la formation s'appuie-t-elle ?
Le socle est Java 21, première LTS à embarquer les virtual threads, et le contenu intègre les apports de Java 25, la LTS la plus récente. Le cycle est régulier : une LTS tous les deux ans, des versions intermédiaires tous les six mois (Java 26 par exemple). Les équipes encore sur Java 8, 11 ou 17 sont les bienvenues : les écarts de syntaxe sont traités au fil des modules, et la formation sert souvent de point de départ à un chantier de migration.La partie Spring couvre-t-elle Spring Boot 4 ?
Oui. Les travaux pratiques se font sur Spring Boot 4, adossé à Spring Framework 7, avec ses jars modulaires et son support natif de Java 25. Les équipes qui tournent encore sur Spring Boot 3 ne sont pas dépaysées : injection de dépendances, Spring Data JPA, Spring Security et configuration par profils fonctionnent de la même façon. Le formateur signale les points de migration (Jakarta EE 11, Tomcat 11) quand ils se présentent.Pourquoi ne pas confier toute la migration à un agent IA ?
Parce qu'un agent travaille sur le texte qu'il lit, fichier après fichier. Sur une application de 400 classes, il peut en sauter une sans le signaler, reformater des fichiers entiers et noyer les vrais changements dans le diff, et deux exécutions ne donnent pas le même résultat. Une recette OpenRewrite travaille sur un arbre qui connaît les types : même code d'entrée, même diff, ce qui permet de le relire par échantillon. Le partage raisonnable laisse à la recette la masse (versions, imports jakarta, API dépréciées qui ont un remplaçant connu) et à l'agent ce qui reste, les erreurs de compilation et les bibliothèques sans équivalent. Dans les deux cas, les tests de caractérisation passent avant, parce que ni l'outil ni l'agent ne savent ce que le métier attend du code.Java est-il encore un bon choix face à Python ou Go ?
Sur les back-ends d'entreprise, oui. Les cœurs bancaires, les plateformes e-commerce, les moteurs de réservation et une grande partie des traitements Kafka tournent sur la JVM. Les virtual threads ont réglé le vieux reproche du thread par requête trop coûteux, et GraalVM native-image ramène le démarrage sous la seconde pour les déploiements serverless ou Kubernetes. Python garde l'avantage en data science et Go sur l'outillage infra, mais pour une API métier à fort trafic maintenue dix ans, Java avec Spring Boot reste le pari le plus sûr.
Prochaine étape
Construire votre formation Java
Un échange de 20 minutes suffit pour cadrer vos enjeux et la session. Devis personnalisé sous 48h, démarrage sous 15 jours.
- Réponse sous 24h ouvrées
- 01 85 71 00 29

Pour aller plus loin





