# 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. - Published: 2026-11-12 - Updated: 2026-11-12 - Author: Anthony Fillion-Maillet - Tags: spring boot devtools, hot reload, livereload, produttività, testcontainers - Reading time: 11 min --- 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. > **Spring Boot DevTools in sintesi** > > 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. ```xml org.springframework.boot spring-boot-devtools true ``` L'equivalente Gradle occupa una sola riga: ```kotlin // build.gradle.kts 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](https://docs.spring.io/spring-boot/reference/using/devtools.html) 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 `.java` non 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](https://www.jetbrains.com/help/idea/spring-boot.html) 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. ```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 ``` Alcune regole governano queste proprietà e vengono spesso trascurate: - `spring.devtools.restart.exclude` **sostituisce** l'elenco predefinito (`META-INF/maven/**`, `META-INF/resources/**`, `resources/**`, `static/**`, `public/**`, `templates/**`, classi di test e file di build info). `additional-exclude` invece **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.cache` e imposta `spring.web.resources.cache.period` a 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=false` in `application.properties` interrompe il monitoraggio dei file ma inizializza comunque il classloader di riavvio. Per disattivare DevTools del tutto, la proprietà di sistema va impostata nel metodo `main` prima di `SpringApplication.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. ## 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: ```properties # application-dev.properties # Deprecated since Spring Boot 4.1.0, no replacement planned spring.devtools.livereload.enabled=true spring.devtools.livereload.port=35729 ``` Le [note di rilascio di Spring Boot 4.1](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-4.1-Release-Notes) 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. > **Evitare nuovi workflow basati su LiveReload** > > 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: 1. 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ì. 2. Un modulo del progetto viene consumato come jar (una libreria `common` in una build multi-modulo) e finisce nel classloader di base, mentre le classi che lo utilizzano si trovano nel classloader di riavvio. 3. 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: ```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 ``` Le 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](https://docs.spring.io/spring-boot/reference/features/dev-services.html), con i nomi dei package di Testcontainers 2 utilizzati da 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"); } } ``` Il launcher riutilizza il vero metodo `main` e aggiunge la configurazione: ```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'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](https://sharpskill.dev/it/blog/spring-boot/testcontainers-spring-boot-integration-testing). ## 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 `optional` o `developmentOnly`, esclusione dal jar ripacchettizzato e disattivazione automatica con `java -jar`. Una risposta solida ricorda che forzare `spring.devtools.restart.enabled=true` aggira il terzo livello. - **"Da dove nasce `X cannot be cast to X`?"** Da due classloader che caricano la stessa classe; si risolve con `META-INF/spring-devtools.properties` o 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](https://sharpskill.dev/it/technologies/spring-boot/domande-colloquio/spring-boot-devtools) si abbina bene al [modulo su profili e environment](https://sharpskill.dev/it/technologies/spring-boot/domande-colloquio/profiles-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](https://sharpskill.dev/it/technologies/spring-boot). ## Checklist per configurare Spring Boot DevTools nel 2026 - Dichiarare `spring-boot-devtools` come `optional` (Maven) o `developmentOnly` (Gradle) e passare a `testAndDevelopmentOnly` quando si usa un launcher Testcontainers con `bootTestRun`. - 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-exclude` al posto di `exclude`, per conservare le esclusioni predefinite di file statici e template. - Impostare un trigger file nel file globale `~/.config/spring-boot/spring-boot-devtools.properties` quando 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 X` come una divisione tra classloader e correggerla con voci `restart.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. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/it/blog/spring-boot/spring-boot-devtools-hot-reload-livereload