Java moderne — Startup & mémoire (Spring AOT, GraalVM, CRaC, CDS, Leyden)

1📖 Glossaire

• JVM (HotSpot) — machine virtuelle Java standard. Interprète le bytecode et le compile à la volée via le JIT.
• Bytecode — format intermédiaire produit par javac. Portable entre OS, exécuté par la JVM.
• JIT (Just-In-Time) — compilateur intégré à la JVM qui recompile les méthodes chaudes en code machine natif au fur et à mesure.
• JIT adaptatif — le JIT réoptimise en permanence selon les profils d'exécution réels. Avantage de HotSpot sur GraalVM en stable state.
• AOT (Ahead-Of-Time) — l'opposé du JIT. Compilation/optimisation avant exécution, au moment du build.
• Native image — exécutable Linux/Mac/Windows produit à partir de bytecode Java, sans JVM. Démarre instantanément, perd les capacités dynamiques.
• Cold start / scale-to-zero — premier démarrage d'un process (vs un process déjà chaud). Facteur critique en serverless type AWS Lambda.
• CRIU (Checkpoint/Restore In Userspace) — outil Linux qui fige un processus en cours d'exécution dans des fichiers, puis le redémarre. Base technique de CRaC et AWS Lambda SnapStart.
• JEP (JDK Enhancement Proposal) — format des propositions d'évolution d'OpenJDK. JEP 483 = AOT Class Loading & Linking (Project Leyden).

2Vue d'ensemble du paysage

flowchart TB
    SA["Spring AOT engine\n(Spring Boot 3+)"]
    SR["Spring Data AOT Repositories\n(Spring Data 2025.1)"]
    GV["GraalVM native image"]
    CR["CRaC"]
    CDS["AppCDS / CDS"]
    PL["Project Leyden\n(Java 24/25)"]

    SA --> SR
    SA -.utilisé par.-> GV
    SA -.compatible avec.-> CR
    SA -.compatible avec.-> CDS

Quatre niveaux superposés :

• Niveau framework — Spring AOT engine + Spring Data AOT Repositories : build-time processing du code Spring.
• Niveau compilateur — GraalVM : compile le bytecode en exécutable natif.
• Niveau JVM — CDS, Leyden, CRaC : accélèrent ou snapshottent la JVM standard.
• Niveau orchestration — combinaisons selon le contexte (section 9).

3Spring AOT engine

Au démarrage, Spring Boot scanne toutes les classes annotées, résout les dépendances, crée les beans, évalue les conditions @ConditionalOn.... L'engine fait ce travail au build (mvn package) et génère du code Java qui contient déjà les bean definitions résolues.

Ce que ça inclut :

• Pré-calcul des bean definitions (au lieu de scanner les annotations au démarrage)
• Pré-évaluation des conditions Spring Boot
• Préparation des hints de réflexion pour GraalVM
• Pré-compilation des expressions SpEL statiques

Activation :

# application.properties — Spring Boot 3+
spring.aot.enabled=true

mvn clean package
# Le code généré atterrit dans target/spring-aot/main/sources/

Aucun plugin supplémentaire requis — le plugin spring-boot-maven-plugin gère tout.

4GraalVM native image

Compile tout le code Java en exécutable natif autonome (plus de JVM, plus de JIT). Démarre directement comme un programme C. La réflexion non déclarée casse ce modèle — il faut des hints listant explicitement ce qui sera accédé par réflexion. Spring AOT génère ces hints automatiquement.

Activation :

<!-- pom.xml -->
<plugin>
    <groupId>org.graalvm.buildtools</groupId>
    <artifactId>native-maven-plugin</artifactId>
    <extensions>true</extensions>
</plugin>

# Requiert GraalVM JDK (sdk install java 21.0.5-graal)
mvn -Pnative native:compile
# Build 2-5 min → exécutable autonome dans target/
./target/mon-app   # démarre en 20-50 ms

5CRaC — Coordinated Restore at Checkpoint

Démarrer l'appli une fois, la laisser chauffer (JIT optimise), puis prendre un snapshot de la JVM en mémoire : heap, stack, classes chargées, code JIT-compilé. En prod, restaurer ce snapshot en ~50 ms au lieu de redémarrer from scratch.

flowchart LR
    subgraph CI["Build / CI"]
        S1["Start JVM"] --> W1["Warmup\n(JIT chauffe)"]
        W1 --> CP["Checkpoint\n(snapshot)"]
        CP --> SN[("Fichiers snapshot")]
    end
    subgraph PROD["Prod"]
        SN --> R1["Restore\n~50 ms"]
        R1 --> READY["App ready\nJIT déjà chaud"]
    end

Les connexions TCP ne survivent pas — il faut les fermer avant le checkpoint et les rouvrir après. Spring Boot 3.2+ fait ça automatiquement pour les ressources standard (DataSource, Tomcat, Kafka clients).

Activation :

# JDK avec support CRaC (Azul Zulu CRaC, Liberica, Corretto 21+)
java -XX:CRaCCheckpointTo=./checkpoint-data -jar target/mon-app.jar

# Depuis un autre terminal, déclencher le snapshot
jcmd <PID> JDK.checkpoint

# En prod — restauration en ~50 ms
java -XX:CRaCRestoreFrom=./checkpoint-data

6CDS et AppCDS — Class Data Sharing

Au démarrage, la JVM reparse les mêmes milliers de classes à chaque fois. CDS fait ce travail une seule fois, sauvegarde le résultat dans un .jsa, et le mappe directement en mémoire au démarrage suivant. Gain typique : 20-40% de startup, sans toucher au code.

Technique la plus indolore du paysage — à activer par défaut.

# Méthode Spring Boot 3.3+
mvn clean package

# Génération du .jsa
java -Dspring.context.exit=onRefresh \
     -XX:ArchiveClassesAtExit=app.jsa \
     -jar target/mon-app.jar

# Utilisation en prod
java -XX:SharedArchiveFile=app.jsa -jar target/mon-app.jar

# Via Cloud Native Buildpacks (automatisé)
mvn spring-boot:build-image \
  -Dspring-boot.build-image.env.BP_JVM_CDS_ENABLED=true

7Project Leyden (JEP 483)

Extension de CDS qui pré-charge ET pré-linke les classes encore plus agressivement. Gain typique : 40-50% de startup en moins, juste avec un flag, sans changer de JVM ni perdre le dynamique HotSpot.

Disponible à partir de Java 24 (preview) / Java 25 (GA).

# Phase 1 — Entraînement (une exécution normale d'observation)
java -XX:AOTMode=record \
     -XX:AOTConfiguration=app.aotconf \
     -jar target/mon-app.jar

# Phase 2 — Création de l'archive AOT
java -XX:AOTMode=create \
     -XX:AOTConfiguration=app.aotconf \
     -XX:AOTCache=app.aot \
     -jar target/mon-app.jar

# Phase 3 — Utilisation en prod
java -XX:AOTCache=app.aot -jar target/mon-app.jar

JEP 514 (Java 25) simplifiera ce flux à un seul flag.

8Tableau de synthèse

9Comment elles se combinent

Ces techniques ne s'excluent pas. Spring AOT est une fondation, les autres sont complémentaires.

• Backend classique JVM → Spring AOT + AppCDS + Leyden (dès Java 24+). Cumulé : 50-60% de startup en moins, zéro contrainte de code.
• Serverless / scale-to-zero → Spring AOT + GraalVM. Champion si tu peux te passer du dynamique.
• Gros warmup, redémarrages fréquents → Spring AOT + CRaC. JVM gardée, pré-chauffée.

Sources

• Spring Framework — Spring AOT — engine AOT, hints de réflexion, Spring Data AOT Repositories
• GraalVM — Native Image — compilation native, hints, limitations
• OpenJDK — JEP 460: CRaC — spécification CRaC
• Spring Blog — Spring Boot with CRaC — activation pas-à-pas Spring Boot 3.2+
• OpenJDK — Class Data Sharing — CDS AppCDS référence
• Spring Blog — CDS in Spring Boot 3.3 — activation Spring Boot 3.3
• OpenJDK — JEP 483: Ahead-of-Time Class Loading & Linking — Project Leyden
• spring-boot-transactional-propagation-isolation-appels-entre-beans — si tu actives Spring AOT, les frontières transactionnelles doivent être correctement définies au build