# Spring Boot DevTools en 2026 : hot reload, LiveReload et productivité du développeur > Guide complet de Spring Boot DevTools en 2026 : installation Maven et Gradle, fonctionnement du redémarrage automatique, propriétés spring.devtools, fin de LiveReload, @RestartScope avec Testcontainers et questions d'entretien. - Published: 2026-11-12 - Updated: 2026-11-12 - Author: Anthony Fillion-Maillet - Tags: spring boot devtools, hot reload, livereload, productivité développeur, testcontainers - Reading time: 11 min --- Modifier une classe, recompiler, relancer le serveur, attendre vingt secondes, recommencer : Spring Boot DevTools existe pour casser cette boucle. Le module redémarre uniquement le code du projet, en une ou deux secondes, sans relancer la JVM. En 2026, avec Spring Boot 4.1 (version stable 4.1.2 au moment de la rédaction), le redémarrage automatique reste la fonctionnalité centrale de DevTools, tandis que LiveReload est désormais officiellement déprécié. > **DevTools en bref** > > DevTools répartit le classpath entre deux classloaders : un classloader de base pour les jars tiers et un classloader de redémarrage pour les classes du projet. À chaque modification compilée, seul le second est jeté puis recréé, d'où un redémarrage bien plus rapide qu'un démarrage à froid. DevTools coupe aussi le cache des templates et se désactive tout seul dès que l'application tourne via `java -jar`. ## Installer spring-boot-devtools sans polluer la production DevTools tient en une seule dépendance. Le point qui compte, c'est la portée : la dépendance ne doit ni se propager aux autres modules, ni se retrouver dans l'archive de production. Maven l'exprime avec `optional`, Gradle avec la configuration `developmentOnly` fournie par le plugin Spring Boot. ```xml org.springframework.boot spring-boot-devtools true ``` Côté Gradle, une ligne suffit : ```kotlin // build.gradle.kts dependencies { // developmentOnly: on the classpath for bootRun, absent from bootJar developmentOnly("org.springframework.boot:spring-boot-devtools") } ``` Les plugins Maven et Gradle retirent DevTools du jar repackagé par défaut. Deuxième filet de sécurité : DevTools détecte un lancement « entièrement packagé » (`java -jar` ou classloader de lanceur personnalisé) et se désactive, car la [documentation officielle de DevTools](https://docs.spring.io/spring-boot/reference/using/devtools.html) considère ce type de lancement comme de la production. Il reste possible de le forcer avec `-Dspring.devtools.restart.enabled=true`, et c'est précisément ce qu'un déploiement de production doit éviter. ## Hot reload Spring Boot : ce qui se passe vraiment L'expression « hot reload Spring Boot » prête à confusion. DevTools ne remplace pas de bytecode à chaud dans une JVM en cours d'exécution : il effectue un **redémarrage**, mais un redémarrage peu coûteux. Le tableau suivant situe DevTools parmi les autres approches. | Mécanisme | Ce qui change sans redémarrage | Coût par modification | Outillage | |---|---|---|---| | HotSwap JVM (débogueur) | Corps de méthodes uniquement | Quasi nul | Débogueur de n'importe quel IDE | | Redémarrage DevTools | Toute classe, tout bean, toute config | Généralement 1 à 3 secondes | `spring-boot-devtools` | | Redémarrage complet | Tout | Temps de démarrage complet | Aucun | | Agents de rechargement | La plupart des changements de structure | Quasi nul | JRebel et équivalents | La rapidité vient de la séparation en deux classloaders. Les jars récupérés depuis Maven Central ne bougent quasiment jamais pendant une session de développement : ils restent chargés dans le classloader de base, avec tout le travail de compilation JIT déjà effectué. Les classes du projet, issues de `target/classes` ou `build/classes`, vivent dans le classloader de redémarrage. Une modification entraîne l'abandon de ce classloader, la création d'un nouveau, puis la reconstruction complète de l'`ApplicationContext`. Deux conséquences pratiques en découlent : - **L'état en mémoire disparaît.** Caches locaux, sessions HTTP stockées en mémoire, progression des tâches planifiées : tout est perdu à chaque redémarrage. C'est voulu, puisque le contexte est reconstruit. - **Le déclencheur est le classpath, pas l'éditeur.** DevTools surveille la sortie de compilation. Enregistrer un fichier `.java` ne produit rien tant que l'IDE ou l'outil de build ne l'a pas compilé. Ce second point explique la majorité des signalements du type « DevTools ne marche pas ». Dans IntelliJ IDEA, il faut lancer un build (Ctrl+F9 / Cmd+F9) ou activer « Build project automatically », accompagné du réglage avancé qui autorise l'auto-make pendant l'exécution de l'application. La [documentation Spring Boot d'IntelliJ IDEA](https://www.jetbrains.com/help/idea/spring-boot.html) détaille les options de configuration d'exécution (« On update action », « On frame deactivation ») qui déclenchent cette compilation. Eclipse et Spring Tools compilent à l'enregistrement : le redémarrage fonctionne sans configuration supplémentaire. ## Régler le redémarrage automatique avec les propriétés spring.devtools Le comportement de DevTools se pilote avec les propriétés `spring.devtools.*`. Les valeurs par défaut de Spring Boot 4.1.2 éclairent plusieurs comportements déroutants : l'observateur de fichiers interroge le disque toutes les **1 seconde** et attend une période de calme de **400 ms** avant de redémarrer. Ainsi, une compilation qui touche cinq fichiers ne provoque qu'un seul redémarrage. La configuration ci-dessous adapte DevTools à un projet qui compile lentement (gros build multi-modules, lecteur réseau, volume Docker) et qui sert des ressources statiques depuis un dossier de build frontend. ```properties # src/main/resources/application-dev.properties # Watch less often and wait longer before restarting: avoids double restarts on slow compiles spring.devtools.restart.poll-interval=2s spring.devtools.restart.quiet-period=1s # Keep the default exclusions (static/**, templates/**...) and add one more folder spring.devtools.restart.additional-exclude=generated/** # Watch a folder outside the classpath (shared contract files, for example) spring.devtools.restart.additional-paths=../shared-contracts/src/main/resources # Restart only when this file is touched, not on every compile spring.devtools.restart.trigger-file=.reloadtrigger # Keep the condition evaluation delta report short on each restart spring.devtools.restart.log-condition-evaluation-delta=false ``` Quelques règles encadrent ces propriétés : - `spring.devtools.restart.exclude` **remplace** la liste par défaut (`META-INF/maven/**`, `META-INF/resources/**`, `resources/**`, `static/**`, `public/**`, `templates/**`, classes de test et fichiers d'informations de build). `additional-exclude` **complète** cette liste, ce qui correspond presque toujours à l'intention réelle. - Les ressources exclues ne déclenchent pas de redémarrage, mais elles sont tout de même servies à jour : DevTools désactive les caches comme `spring.thymeleaf.cache` et fixe `spring.web.resources.cache.period` à 0. - Le fichier déclencheur doit se trouver sur le classpath (`src/main/resources/.reloadtrigger`). IntelliJ IDEA Ultimate et Spring Tools savent tous deux le mettre à jour après un build. - `spring.devtools.restart.enabled=false` dans `application.properties` arrête la surveillance des fichiers mais initialise quand même le classloader de redémarrage. Pour désactiver complètement DevTools, la propriété système doit être positionnée dans `main`, avant l'appel à `SpringApplication.run`. Pour des réglages valables sur tous les projets d'un poste, DevTools lit un fichier global dans `$HOME/.config/spring-boot/`, nommé `spring-boot-devtools.properties` (ou `.yaml` / `.yml`). C'est l'endroit idéal pour une préférence personnelle comme le fichier déclencheur, qui n'a pas sa place dans le dépôt de l'équipe. Les profils ne sont pas pris en charge dans ce fichier. ## LiveReload dans Spring Boot : déprécié depuis la 4.1 LiveReload rafraîchit automatiquement le navigateur lorsqu'une ressource change. DevTools embarque un serveur compatible LiveReload sur le port 35729, auquel se connecte une extension de navigateur. Depuis Spring Boot 4.1, ce serveur est désactivé par défaut et doit être activé explicitement : ```properties # application-dev.properties # Deprecated since Spring Boot 4.1.0, no replacement planned spring.devtools.livereload.enabled=true spring.devtools.livereload.port=35729 ``` Les [notes de version de Spring Boot 4.1](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-4.1-Release-Notes) sont sans ambiguïté : la fonctionnalité LiveReload de DevTools est dépréciée, sans remplacement prévu, en raison de sa baisse de popularité et de support. Les extensions de navigateur ne sont presque plus maintenues, et la plupart des frontends de 2026 tournent avec Vite ou un autre serveur de développement qui fournit déjà le remplacement de modules à chaud (HMR). > **Ne pas bâtir un nouveau workflow sur LiveReload** > > Les projets Thymeleaf existants peuvent conserver `spring.devtools.livereload.enabled=true` pour l'instant, mais une propriété dépréciée dans Spring Boot est candidate à la suppression dans une version majeure ultérieure. Pour les templates rendus côté serveur, la désactivation des caches appliquée par DevTools suffit : un simple rafraîchissement manuel du navigateur affiche la dernière version du template, sans redémarrer l'application. ## Pièges du classloader de redémarrage et ClassCastException Le bug DevTools le plus fréquent semble absurde : `com.example.Order cannot be cast to com.example.Order`. Les deux noms sont identiques parce que les deux classes proviennent de deux classloaders différents. Un `Order` a été chargé par le classloader de redémarrage, l'autre par le classloader de base (ou par un ancien classloader de redémarrage qui aurait dû être abandonné). Trois situations typiques mènent à ce cas : 1. Une bibliothèque désérialise des objets avec un `ObjectInputStream` standard, qui résout les classes via le mauvais classloader. La réplication de sessions et certains caches procèdent ainsi. 2. Un module du projet est consommé sous forme de jar (une bibliothèque `common` dans un build multi-modules) et atterrit dans le classloader de base, alors que les classes qui l'utilisent sont dans le classloader de redémarrage. 3. Un champ statique conserve une instance créée avant le dernier redémarrage. Pour le deuxième cas, DevTools lit un fichier `META-INF/spring-devtools.properties` sur le classpath. Ses clés déplacent des jars d'un classloader à l'autre à l'aide d'expressions régulières : ```properties # src/main/resources/META-INF/spring-devtools.properties # Load the team's shared domain jar in the restart classloader, so it restarts with the app restart.include.shared-domain=/orders-shared-domain-[\\w\\d.-]+\\.jar # Keep a heavy internal SDK in the base classloader, it never changes during development restart.exclude.payments-sdk=/payments-sdk-[\\w\\d.-]+\\.jar ``` Les clés doivent simplement être uniques : seul le préfixe `restart.include.` ou `restart.exclude.` a une signification. Pour le premier cas, la solution consiste à désérialiser avec le `ConfigurableObjectInputStream` de Spring en lui passant `Thread.currentThread().getContextClassLoader()`, qui pointe vers le classloader de redémarrage courant. Si les redémarrages restent trop lents ou si les conflits de classloaders ne peuvent pas être résolus, la documentation renvoie vers un agent de rechargement comme JRebel, qui redéfinit les classes sur place au lieu de reconstruire le contexte. ## DevTools, Testcontainers et @RestartScope Depuis Spring Boot 3.1, un projet peut démarrer ses bases de données et ses brokers via Testcontainers pendant le développement, grâce à une classe de lancement placée dans `src/test/java`. Combiné à des redémarrages naïfs, le résultat est pénible : chaque redémarrage détruit puis recrée le conteneur PostgreSQL, ce qui coûte plusieurs secondes et efface les données. `@RestartScope`, fourni par le module DevTools, règle exactement ce problème : un bean annoté survit aux redémarrages DevTools. La configuration suivante reprend le [guide des services de développement de Spring Boot](https://docs.spring.io/spring-boot/reference/features/dev-services.html), avec les noms de packages de Testcontainers 2 utilisés par Spring Boot 4. ```java // src/test/java/com/example/orders/DevContainersConfiguration.java package com.example.orders; import org.springframework.boot.devtools.restart.RestartScope; import org.springframework.boot.test.context.TestConfiguration; import org.springframework.boot.testcontainers.service.connection.ServiceConnection; import org.springframework.context.annotation.Bean; import org.testcontainers.postgresql.PostgreSQLContainer; @TestConfiguration(proxyBeanMethods = false) public class DevContainersConfiguration { @Bean @RestartScope // the container is kept across DevTools restarts @ServiceConnection // datasource URL, user and password wired automatically PostgreSQLContainer postgres() { return new PostgreSQLContainer("postgres:17-alpine"); } } ``` La classe de lancement réutilise la vraie méthode `main` et y ajoute cette configuration : ```java // src/test/java/com/example/orders/TestOrdersApplication.java package com.example.orders; import org.springframework.boot.SpringApplication; public class TestOrdersApplication { public static void main(String[] args) { // Starts OrdersApplication with the containers declared above SpringApplication.from(OrdersApplication::main) .with(DevContainersConfiguration.class) .run(args); } } ``` L'application se lance avec `./mvnw spring-boot:test-run` ou `./gradlew bootTestRun`. Un détail Gradle casse silencieusement ce montage : avec `developmentOnly`, DevTools n'est pas sur le classpath de `bootTestRun`, et les modifications de code sont donc ignorées. La dépendance doit passer en `testAndDevelopmentOnly("org.springframework.boot:spring-boot-devtools")`. Le volet tests d'intégration de cette approche est traité dans le [guide Testcontainers avec Spring Boot](https://sharpskill.dev/fr/blog/spring-boot/testcontainers-spring-boot-tests-integration). ## DevTools à distance : pourquoi la production reste hors limites DevTools peut aussi pousser des modifications vers une application qui tourne ailleurs, par exemple dans un conteneur sur un serveur de développement partagé. Le côté serveur ne s'active que si `spring.devtools.remote.secret` est défini et si DevTools est explicitement embarqué dans l'archive (`excludeDevtools=false` sur le plugin Maven). Le client, `org.springframework.boot.devtools.RemoteSpringApplication`, se lance depuis l'IDE avec l'URL distante en argument. La documentation fixe des limites claires : DevTools à distance ne doit fonctionner que sur un réseau de confiance ou en HTTPS, jamais en production, et ne prend pas en charge les applications Spring WebFlux. Un endpoint qui accepte des fichiers de classes et redémarre l'application constitue, par construction, un canal d'exécution de code à distance. Dans la plupart des configurations de 2026, exécuter l'application en local avec Testcontainers ou Docker Compose offre une boucle plus rapide, sans aucune de ces expositions. ## Questions d'entretien sur Spring Boot DevTools En entretien Spring Boot, DevTools sert souvent de porte d'entrée vers un sujet plus profond : le chargement des classes et le cycle de vie du contexte applicatif. Voici les questions les plus courantes, avec la réponse attendue d'un développeur confirmé : - **« DevTools fait-il du hot swap ou un redémarrage ? »** Un redémarrage. Il abandonne le classloader de redémarrage et reconstruit l'`ApplicationContext` ; la JVM et le classloader de base restent en vie. Répondre « hot swap » est l'erreur classique de profil junior. - **« Pourquoi peut-on laisser DevTools dans le pom sans risque ? »** Trois couches de protection : la portée `optional` ou `developmentOnly`, l'exclusion du jar repackagé, et la désactivation automatique sous `java -jar`. Une bonne réponse précise que forcer `spring.devtools.restart.enabled=true` contourne la troisième couche. - **« D'où vient l'erreur `X cannot be cast to X` ? »** De deux classloaders qui chargent la même classe ; correction via `META-INF/spring-devtools.properties` ou le classloader de contexte. - **« Que devient un cache en mémoire au redémarrage ? »** Il est perdu, sauf si le bean est placé dans `@RestartScope`. Ces questions recoupent les sujets de configuration : le [module de questions d'entretien sur Spring Boot DevTools](https://sharpskill.dev/fr/technologies/spring-boot/questions-entretien/spring-boot-devtools) se travaille utilement avec le [module sur les profils et l'environnement](https://sharpskill.dev/fr/technologies/spring-boot/questions-entretien/profiles-environment), puisqu'un profil `dev` est l'endroit naturel de la plupart des propriétés présentées plus haut. L'ensemble des questions est disponible sur la [page technologie Spring Boot](https://sharpskill.dev/fr/technologies/spring-boot). ## Check-list DevTools pour un projet Spring Boot en 2026 - Déclarer `spring-boot-devtools` en `optional` (Maven) ou `developmentOnly` (Gradle), et passer à `testAndDevelopmentOnly` pour un lanceur Testcontainers exécuté avec `bootTestRun`. - Vérifier que l'IDE compile à l'enregistrement ou à la perte de focus : DevTools surveille les classes compilées, pas les fichiers sources. - Préférer `spring.devtools.restart.additional-exclude` à `exclude`, afin de conserver les exclusions par défaut des ressources statiques et des templates. - Définir un fichier déclencheur dans le fichier global `~/.config/spring-boot/spring-boot-devtools.properties` lorsque les redémarrages incessants gênent pendant un refactoring. - Considérer LiveReload comme déprécié depuis Spring Boot 4.1.0 et s'appuyer sur le serveur de développement frontend ou sur un rafraîchissement manuel. - Annoter les conteneurs de développement avec `@RestartScope` pour que PostgreSQL ou Kafka survivent à chaque redémarrage. - Diagnostiquer `X cannot be cast to X` comme une séparation de classloaders et la corriger avec des entrées `restart.include`. ## Conclusion Spring Boot DevTools reste en 2026 l'outil le plus simple pour raccourcir la boucle de développement d'une application Java : une dépendance bien scopée, un IDE qui compile au bon moment, et quelques propriétés `spring.devtools.restart.*` ajustées au projet suffisent à ramener chaque cycle à quelques secondes. Comprendre le mécanisme des deux classloaders permet d'éviter les pièges classiques, de tirer parti de `@RestartScope` avec Testcontainers, et de répondre avec précision aux questions d'entretien sur le sujet. LiveReload, en revanche, appartient au passé et ne mérite plus d'investissement. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/fr/blog/spring-boot/spring-boot-devtools-hot-reload-livereload