back java spring-boot

Spring Boot DevTools - le turbo gratuit de vos développements

Réduire le cycle « modifier → compiler → redéployer » est au cœur de la productivité des développeurs Java depuis des décennies.
Dans l’écosystème Spring Boot, **Spring Boot DevTools** est l’outil officiel et gratuit qui vise à raccourcir ce cycle via un redémarrage rapide et un LiveReload côté navigateur.

Pour des besoins plus avancés (rechargement de modifications structurelles sans perdre l’état), il existe des alternatives open-source comme **HotSwapAgent** et **DCEVM** — qui demandent plus d’efforts d’intégration mais peuvent compléter DevTools.

Présentation

Spring Boot DevTools est un module officiel de Spring Boot destiné exclusivement au développement. Ses fonctions principales :

⚖️ Avantages et inconvénients

➕ Avantages

➖ Inconvénients

Installation rapide

Maven

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

Le flag optional évite que DevTools ne se retrouve dans les dépendances transitives. En pratique, on ne l’embarque jamais dans un jar de production.

Gradle

dependencies {
    developmentOnly("org.springframework.boot:spring-boot-devtools")
}

Ce qui redémarre et ce qui ne redémarre pas

Spring Boot DevTools se déclenche sur les changements de classes (classpath) et redémarre le classloader restart.
Autrement dit, tant que l’IDE ne recompile pas, il ne se passe rien.

Ce qui redémarre :

Ce qui ne redémarre pas (mais peut être rechargé côté navigateur) :

Pour ces ressources, DevTools s’appuie sur LiveReload, ce qui évite un restart complet à chaque changement.

LiveReload (et pourquoi c’est utile avec Thymeleaf)

DevTools embarque un petit serveur LiveReload. Si une page HTML ou un template change, le navigateur se rafraîchit automatiquement.

Pour que cela fonctionne correctement :

  1. On garde spring.devtools.livereload.enabled=true (par défaut).
  2. On installe l’extension LiveReload dans le navigateur ou on utilise un navigateur compatible.
  3. On désactive les caches de templates (DevTools le fait automatiquement).

Ça marche particulièrement bien quand on utilise Thymeleaf : le cycle devient presque instantané.

Configuration utile en dev

Quelques propriétés pratiques pour affiner le comportement :

# Activer/désactiver DevTools
spring.devtools.restart.enabled=true

# Exclure des répertoires du restart
spring.devtools.restart.exclude=static/**,public/**,templates/**

# Ajouter des répertoires supplémentaires à surveiller
spring.devtools.restart.additional-paths=../shared-lib/target/classes

# LiveReload
spring.devtools.livereload.enabled=true
spring.devtools.livereload.port=35730

Les exclusions permettent d’éviter des redémarrages inutiles pour des fichiers qui ne le nécessitent pas.

IDE : le vrai point d’attention

Le point qui fait souvent croire que DevTools « ne marche pas », c’est l’IDE.

IntelliJ

Pour que DevTools redémarre automatiquement, il faut que la compilation se fasse en arrière‑plan. Sinon, DevTools attendra un Build explicite.

  1. Settings > Build, Execution, Deployment > Compiler
  2. Activer Build project automatically

[!note] Capture d’écran ici
Settings > Build, Execution, Deployment > Compiler avec Build project automatically activé.

Ensuite, il faut autoriser l’auto‑make quand l’appli tourne :

  1. Help > Find Action puis Registry…
  2. Activer compiler.automake.allow.when.app.running

[!note] Capture d’écran ici
Fenêtre Registry avec compiler.automake.allow.when.app.running activé.

Optionnel mais pratique selon les habitudes :

[!note] Capture d’écran ici
Settings > Advanced Settings avec les options de synchronisation.

Multi‑modules : le cas qui fâche

Dans un projet multi‑module, un module peut compiler sans pour autant déclencher DevTools si ses classes ne sont pas sur le classpath du module lancé.

Deux solutions simples :

spring.devtools.restart.additional-paths=../module-a/target/classes,../module-b/target/classes

Si certains modules provoquent des redémarrages inutiles, on peut aussi les exclure :

spring.devtools.restart.exclude=module-legacy/**

DevTools et caches (Thymeleaf, Jackson, etc.)

DevTools active un ensemble de dev‑defaults :

C’est pour ça qu’on observe souvent un comportement différent entre dev et prod : ce n’est pas un bug, c’est volontaire.

Points d’attention en production

DevTools est désactivé par défaut dès que l’application est packagée (jar/war).
Pour éviter toute surprise :

Troubleshooting rapide

Le restart ne se déclenche pas

Trop de redémarrages

LiveReload ne fonctionne pas

DevTools vs HotSwapAgent / DCEVM

DevTools vise la simplicité et la stabilité.
HotSwapAgent + DCEVM visent le hot‑swap avancé (modifs structurelles) au prix d’une installation plus lourde.

Dans la majorité des projets, DevTools suffit.
Quand on travaille sur des gros modèles qui changent souvent, on peut compléter avec HotSwapAgent.

En résumé

Si l’on cherche un gain immédiat de productivité sans complexité, DevTools est le meilleur point de départ.
Il ne remplace pas les solutions de hot‑swap avancées, mais il couvre 80% des besoins avec 0 friction.

Et quand on le combine avec Thymeleaf ou des outils d’observabilité comme Superviser votre application Spring Boot grâce à Prometheus et Grafana, le confort de dev devient franchement agréable.