Spring Boot DevTools nel 2026: hot reload, LiveReload e produttività dello sviluppatore
Guida pratica a Spring Boot DevTools nel 2026: riavvio automatico, classloader di riavvio, LiveReload deprecato in 4.1, @RestartScope con Testcontainers e domande da colloquio.

Nello sviluppo di un'applicazione Spring Boot, una parte sorprendente della giornata se ne va in attese: modificare il codice, ricompilare, fermare l'applicazione, riavviarla, aggiornare il browser. Spring Boot DevTools riduce questo ciclo a uno o due secondi, ricaricando soltanto la porzione di applicazione che è effettivamente cambiata. Con Spring Boot 4.1 (la linea stabile attuale, alla versione 4.1.2) il riavvio automatico resta la funzionalità centrale del modulo, mentre LiveReload è stato ufficialmente deprecato. Questa guida mostra come configurare DevTools nel 2026, dove si nascondono gli errori più frequenti e quali domande emergono sull'argomento durante i colloqui tecnici.
DevTools divide il classpath tra due classloader: un classloader di base per le librerie di terze parti e un classloader di riavvio per le classi del progetto. Quando una classe compilata cambia, viene scartato e ricreato solo il classloader di riavvio, il che rende il riavvio molto più rapido di un avvio a freddo. DevTools disattiva inoltre la cache dei template e si spegne da solo nelle applicazioni pacchettizzate avviate con java -jar.
Aggiungere correttamente la dipendenza spring-boot-devtools
DevTools è un singolo artefatto. Il dettaglio che conta davvero è lo scope: la dipendenza non deve propagarsi ad altri moduli né finire nell'archivio di produzione. Maven lo esprime con optional, Gradle con la configurazione developmentOnly fornita dal plugin Spring Boot.
<!-- pom.xml -->
<dependencies>
<!-- Version is managed by spring-boot-starter-parent 4.1.x -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<!-- optional: not propagated to modules that depend on this one -->
<optional>true</optional>
</dependency>
</dependencies>L'equivalente Gradle occupa una sola riga:
dependencies {
// developmentOnly: on the classpath for bootRun, absent from bootJar
developmentOnly("org.springframework.boot:spring-boot-devtools")
}Sia il plugin Maven sia quello Gradle escludono DevTools dal jar ripacchettizzato per impostazione predefinita. In aggiunta, DevTools riconosce un avvio "completamente pacchettizzato" (java -jar o un classloader di avvio personalizzato) e si disattiva, perché la documentazione ufficiale di DevTools considera un avvio di questo tipo come produzione. È possibile forzarne l'attivazione con -Dspring.devtools.restart.enabled=true, ed è esattamente ciò che un deployment in produzione deve evitare.
Come funziona davvero l'hot reload di Spring Boot
L'espressione "hot reload di Spring Boot" è in parte fuorviante. DevTools non sostituisce il bytecode all'interno di una JVM in esecuzione: esegue un riavvio, ma un riavvio molto economico. Il confronto con gli altri meccanismi disponibili chiarisce la differenza.
| Meccanismo | Cosa cambia senza riavvio | Costo per modifica | Strumenti |
|---|---|---|---|
| HotSwap della JVM (debugger) | Solo il corpo dei metodi | Quasi nullo | Qualsiasi debugger dell'IDE |
| Riavvio DevTools | Qualsiasi classe, bean o configurazione | Di solito da 1 a 3 secondi | spring-boot-devtools |
| Riavvio completo | Tutto | Tempo di avvio completo | Nessuno |
| Agent di reloading | La maggior parte delle modifiche strutturali | Quasi nullo | JRebel e simili |
È il modello a due classloader a rendere il riavvio veloce. I jar provenienti da Maven Central cambiano raramente durante una sessione di lavoro, quindi restano caricati nel classloader di base insieme al lavoro di compilazione JIT già svolto. Le classi del progetto, in target/classes o build/classes, risiedono invece nel classloader di riavvio. A ogni modifica questo loader viene scartato, ne viene creato uno nuovo e l'ApplicationContext viene ricostruito da zero.
Ne derivano due conseguenze con un peso concreto nel lavoro quotidiano:
- Lo stato va perso. Cache in memoria, sessioni conservate in memoria e avanzamento dei task pianificati scompaiono a ogni riavvio. È un comportamento voluto, perché il contesto viene ricreato.
- Il riavvio è innescato dal classpath, non dall'editor. DevTools osserva l'output compilato. Salvare un file
.javanon produce alcun effetto finché l'IDE o lo strumento di build non lo compila.
Il secondo punto spiega la maggior parte delle segnalazioni del tipo "DevTools non funziona". In IntelliJ IDEA il progetto va compilato (Ctrl+F9 / Cmd+F9), oppure va attivata l'opzione "Build project automatically" insieme all'impostazione avanzata che consente la compilazione automatica mentre l'applicazione è in esecuzione. La documentazione di IntelliJ IDEA su Spring Boot descrive le opzioni della run configuration ("On update action", "On frame deactivation") che attivano questa compilazione. Eclipse e Spring Tools compilano al salvataggio, quindi il riavvio avviene senza configurazioni aggiuntive.
Regolare il riavvio automatico con le proprietà spring.devtools
DevTools si configura tramite le proprietà spring.devtools.*. I valori predefiniti di Spring Boot 4.1.2 meritano attenzione, perché spiegano diversi comportamenti inattesi: il watcher dei file controlla le modifiche ogni secondo e attende un periodo di quiete di 400 ms prima di riavviare, così che una compilazione su più file produca un unico riavvio invece di cinque.
La configurazione seguente adatta DevTools a un progetto che compila lentamente (build multi-modulo di grandi dimensioni, disco di rete, volume Docker) e che serve asset statici da una cartella di build del frontend.
# 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=falseAlcune regole governano queste proprietà e vengono spesso trascurate:
spring.devtools.restart.excludesostituisce l'elenco predefinito (META-INF/maven/**,META-INF/resources/**,resources/**,static/**,public/**,templates/**, classi di test e file di build info).additional-excludeinvece aggiunge elementi all'elenco, ed è quasi sempre l'intenzione reale.- Le risorse escluse non provocano un riavvio, ma vengono comunque servite aggiornate, perché DevTools disattiva cache come
spring.thymeleaf.cachee impostaspring.web.resources.cache.perioda 0. - Il trigger file deve trovarsi nel classpath (
src/main/resources/.reloadtrigger). IntelliJ IDEA Ultimate e Spring Tools sono entrambi in grado di aggiornarlo dopo una build. spring.devtools.restart.enabled=falseinapplication.propertiesinterrompe il monitoraggio dei file ma inizializza comunque il classloader di riavvio. Per disattivare DevTools del tutto, la proprietà di sistema va impostata nel metodomainprima diSpringApplication.run.
Per le impostazioni valide in tutti i progetti di una macchina, DevTools legge un file globale in $HOME/.config/spring-boot/, chiamato spring-boot-devtools.properties (oppure .yaml / .yml). È il posto giusto per un'impostazione personale del trigger file che non deve finire nel repository del team. In questo file i profili non sono supportati.
Pronto a superare i tuoi colloqui su Spring Boot?
Pratica con i nostri simulatori interattivi, flashcards e test tecnici.
LiveReload in Spring Boot: deprecato dalla 4.1
LiveReload aggiorna automaticamente il browser quando una risorsa cambia. DevTools integra un server compatibile con LiveReload sulla porta 35729, a cui si collega un'estensione del browser. In Spring Boot 4.1 il server è disattivato per impostazione predefinita e va abilitato in modo esplicito:
# application-dev.properties
# Deprecated since Spring Boot 4.1.0, no replacement planned
spring.devtools.livereload.enabled=true
spring.devtools.livereload.port=35729Le note di rilascio di Spring Boot 4.1 sono esplicite: a causa del calo di popolarità e di supporto, la funzionalità LiveReload di DevTools è deprecata senza alcun sostituto. Le estensioni per browser sono ormai poco mantenute e, nel 2026, la maggior parte dei frontend viene sviluppata con Vite o con un altro dev server che offre già l'hot module replacement.
I progetti Thymeleaf esistenti possono mantenere spring.devtools.livereload.enabled=true per il momento, ma in Spring Boot una proprietà deprecata è candidata alla rimozione in una versione major successiva. Per i template renderizzati lato server, le impostazioni di cache applicate da DevTools fanno già sì che un semplice aggiornamento manuale del browser mostri il template più recente senza riavviare l'applicazione.
Le insidie del classloader di riavvio e la ClassCastException
Il bug più comune legato a DevTools sembra assurdo: com.example.Order cannot be cast to com.example.Order. I due nomi coincidono perché si tratta della stessa classe caricata da due classloader diversi. Un Order proviene dal classloader di riavvio, l'altro dal classloader di base (oppure da un precedente classloader di riavvio che avrebbe dovuto essere scartato).
Il problema si presenta tipicamente in tre situazioni:
- Una libreria deserializza oggetti con un normale
ObjectInputStream, che risolve le classi attraverso il loader sbagliato. La replica delle sessioni e alcune cache funzionano proprio così. - Un modulo del progetto viene consumato come jar (una libreria
commonin una build multi-modulo) e finisce nel classloader di base, mentre le classi che lo utilizzano si trovano nel classloader di riavvio. - Un campo statico conserva un'istanza creata prima dell'ultimo riavvio.
Per il secondo caso, DevTools legge dal classpath un file META-INF/spring-devtools.properties. Le sue chiavi spostano i jar tra i due classloader tramite espressioni regolari:
# 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.-]+\\.jarLe chiavi devono solo essere univoche: ciò che conta è il prefisso restart.include. o restart.exclude.. Per il primo caso, la soluzione consiste nel deserializzare con il ConfigurableObjectInputStream di Spring passando Thread.currentThread().getContextClassLoader(), che punta al classloader di riavvio corrente.
Quando i riavvii restano comunque troppo lenti o i problemi di classloader non sono risolvibili, la documentazione indica come alternativa un agent di reloading come JRebel, che ridefinisce le classi sul posto invece di riavviare il contesto.
DevTools con Testcontainers e @RestartScope
A partire da Spring Boot 3.1, un progetto può avviare database e broker tramite Testcontainers anche in fase di sviluppo, con una classe launcher in src/test/java. Questo approccio si combina male con riavvii ingenui: ogni riavvio distruggerebbe e ricreerebbe il container PostgreSQL, con un costo di diversi secondi e la perdita di tutti i dati.
@RestartScope, che fa parte del modulo DevTools, risolve esattamente questo problema. Un bean annotato in questo modo sopravvive ai riavvii di DevTools. La configurazione seguente segue la guida di Spring Boot sui servizi in fase di sviluppo, con i nomi dei package di Testcontainers 2 utilizzati da Spring Boot 4.
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");
}
}Il launcher riutilizza il vero metodo main e aggiunge la configurazione:
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'applicazione si avvia con ./mvnw spring-boot:test-run oppure ./gradlew bootTestRun. Un dettaglio di Gradle rompe però questa configurazione in modo silenzioso: con developmentOnly, DevTools non è presente nel classpath di bootTestRun, quindi le modifiche al codice vengono ignorate. La dipendenza va spostata su testAndDevelopmentOnly("org.springframework.boot:spring-boot-devtools"). La parte relativa ai test di integrazione è trattata nella guida a Testcontainers con Spring Boot.
Remote DevTools e perché la produzione resta esclusa
DevTools può anche inviare le modifiche a un'applicazione in esecuzione altrove, per esempio in un container su un server di sviluppo condiviso. Il lato server si attiva solo quando spring.devtools.remote.secret è impostato e quando DevTools viene incluso esplicitamente nell'archivio (excludeDevtools=false nel plugin Maven). Il client è org.springframework.boot.devtools.RemoteSpringApplication, lanciato dall'IDE con l'URL remoto come argomento.
La documentazione non lascia margini di interpretazione: Remote DevTools va usato solo su una rete fidata o in HTTPS, mai in produzione, e non supporta le applicazioni Spring WebFlux. Un endpoint che accetta file di classe e riavvia l'applicazione è, per costruzione, un canale di esecuzione remota di codice. Nella maggior parte delle configurazioni del 2026, eseguire l'applicazione in locale con Testcontainers o con servizi Docker Compose offre un ciclo più rapido e nessuna di queste esposizioni.
Domande da colloquio su Spring Boot DevTools
Nei colloqui su Spring Boot, DevTools funge spesso da porta d'ingresso verso un tema più profondo: il caricamento delle classi e il ciclo di vita dell'application context. Ecco le domande più ricorrenti, con la risposta che ci si aspetta da uno sviluppatore esperto:
- "DevTools esegue un hot swap o un riavvio?" Un riavvio. Scarta il classloader di riavvio e ricostruisce l'
ApplicationContext, mentre la JVM e il classloader di base restano attivi. Rispondere "hot swap" è il classico errore da junior. - "Perché DevTools può restare nel pom senza rischi?" Per tre livelli di protezione: scope
optionalodevelopmentOnly, esclusione dal jar ripacchettizzato e disattivazione automatica conjava -jar. Una risposta solida ricorda che forzarespring.devtools.restart.enabled=trueaggira il terzo livello. - "Da dove nasce
X cannot be cast to X?" Da due classloader che caricano la stessa classe; si risolve conMETA-INF/spring-devtools.propertieso con il classloader di contesto. - "Che fine fa una cache in memoria a ogni riavvio?" Va persa, a meno che il bean non sia in
@RestartScope.
Queste domande si intrecciano con i temi di configurazione: il modulo di domande su Spring Boot DevTools si abbina bene al modulo su profili e environment, dato che la maggior parte delle proprietà viste sopra trova posto in un profilo dev. La raccolta completa di domande è disponibile nella pagina dedicata a Spring Boot.
Checklist per configurare Spring Boot DevTools nel 2026
- Dichiarare
spring-boot-devtoolscomeoptional(Maven) odevelopmentOnly(Gradle) e passare atestAndDevelopmentOnlyquando si usa un launcher Testcontainers conbootTestRun. - Verificare che l'IDE compili al salvataggio o alla perdita del focus della finestra: DevTools osserva le classi compilate, non i file sorgente.
- Usare
spring.devtools.restart.additional-excludeal posto diexclude, per conservare le esclusioni predefinite di file statici e template. - Impostare un trigger file nel file globale
~/.config/spring-boot/spring-boot-devtools.propertiesquando i riavvii continui durante un refactoring diventano un ostacolo. - Considerare LiveReload deprecato da Spring Boot 4.1.0 e affidarsi al dev server del frontend o a un aggiornamento manuale.
- Annotare i container di sviluppo con
@RestartScope, così che PostgreSQL o Kafka sopravvivano a ogni riavvio. - Riconoscere
X cannot be cast to Xcome una divisione tra classloader e correggerla con vocirestart.include.
Configurato con cura, Spring Boot DevTools cambia in modo tangibile la produttività quotidiana su Java: cicli di feedback brevi, container che sopravvivono ai riavvii e una comprensione chiara di ciò che accade dietro le quinte. Proprio questa comprensione, in un colloquio tecnico, distingue una risposta imparata a memoria da un'esperienza reale sul campo.
Inizia a praticare!
Metti alla prova le tue conoscenze con i nostri simulatori di colloquio e test tecnici.
Sapresti trovare il bug in Spring Boot?
Uno snippet reale, un bug nascosto, un tentativo al giorno. Senza account per provare.

Scritto da
Anthony Fillion-MailletFondatore di SharpSkill
Sviluppatore fullstack da oltre 10 anni. Guida SharpSkill e risponde di tutto ciò che vi viene pubblicato.
Aggiornato il 12 novembre 2026
Tag
Condividi
Articoli correlati

Testcontainers Spring Boot: test di integrazione senza dolore
Guida completa alla configurazione di Testcontainers con Spring Boot 3.4. PostgreSQL, Redis e Kafka in container Docker per test di integrazione affidabili e riproducibili.

Lavoro freelance Java Spring Boot sviluppatore 2026: dove trovare contratti, tariffe giornaliere e preparazione
Contratti freelance Java Spring Boot sviluppatore 2026: tariffe giornaliere aggiornate (mediana 440 EUR), migliori piattaforme per progetti in Europa, preparazione ai colloqui tecnici.

Lavoro Sviluppatore Java Spring Boot 2026: Dove Cercare, Fasce Salariali, Come Prepararsi
606 posizioni Spring Boot attive a settembre 2026. Questo articolo analizza dati salariali, percentuali di lavoro remoto e preparazione ai colloqui per sviluppatori Java Spring Boot.