# Spring Boot DevTools in 2026: hot reload, LiveReload en sneller ontwikkelen > Spring Boot DevTools in 2026 goed inrichten: automatische herstart, restart-classloader, LiveReload verouderd in 4.1, @RestartScope met Testcontainers en veelgestelde sollicitatievragen. - Published: 2026-11-12 - Updated: 2026-11-12 - Author: Anthony Fillion-Maillet - Tags: spring boot devtools, hot reload, livereload, productiviteit, testcontainers - Reading time: 11 min --- Wie aan een Spring Boot-applicatie werkt, verliest verrassend veel tijd aan wachten: code aanpassen, opnieuw bouwen, de applicatie stoppen, weer starten en de browser verversen. Spring Boot DevTools brengt die cyclus terug tot een of twee seconden door alleen het deel van de applicatie te herladen dat daadwerkelijk is gewijzigd. In Spring Boot 4.1 (de huidige stabiele lijn, op het moment van schrijven versie 4.1.2) blijft de automatische herstart de kernfunctie van de module, terwijl LiveReload officieel als verouderd is gemarkeerd. Deze handleiding laat zien hoe DevTools in 2026 goed wordt ingericht, waar de bekende valkuilen zitten en welke vragen hierover in sollicitatiegesprekken terugkomen. > **Spring Boot DevTools in het kort** > > DevTools verdeelt het classpath over twee classloaders: een basis-classloader voor bibliotheken van derden en een restart-classloader voor de klassen van het eigen project. Verandert er een gecompileerde klasse, dan wordt alleen de restart-classloader weggegooid en opnieuw aangemaakt. Daardoor is een herstart veel sneller dan een koude start. Daarnaast schakelt DevTools template-caching uit en zet het zichzelf uit in verpakte applicaties die met `java -jar` worden gestart. ## De afhankelijkheid spring-boot-devtools correct toevoegen DevTools bestaat uit één artefact. Het belangrijke detail is de scope: de afhankelijkheid mag niet doorlekken naar andere modules en mag nooit in het productiearchief belanden. Maven legt dat vast met `optional`, Gradle met de configuratie `developmentOnly` die de Spring Boot-plugin aanbiedt. ```xml org.springframework.boot spring-boot-devtools true ``` In Gradle volstaat één regel: ```kotlin // build.gradle.kts dependencies { // developmentOnly: on the classpath for bootRun, absent from bootJar developmentOnly("org.springframework.boot:spring-boot-devtools") } ``` Zowel de Maven- als de Gradle-plugin sluiten DevTools standaard uit van de opnieuw verpakte jar. Bovendien herkent DevTools een "volledig verpakte" start (`java -jar` of een eigen launcher-classloader) en schakelt het zichzelf in dat geval uit, omdat de [officiële DevTools-referentie](https://docs.spring.io/spring-boot/reference/using/devtools.html) zo'n start als productie beschouwt. Met `-Dspring.devtools.restart.enabled=true` valt dat te forceren, en dat is precies wat een productie-deployment moet vermijden. ## Hoe hot reload in Spring Boot echt werkt De term "Spring Boot hot reload" is eigenlijk een beetje misleidend. DevTools vervangt geen bytecode binnen een draaiende JVM, maar voert een **herstart** uit, alleen wel een heel goedkope. Een vergelijking met de andere beschikbare mechanismen maakt het verschil duidelijk. | Mechanisme | Wat verandert zonder herstart | Kosten per wijziging | Tooling | |---|---|---|---| | JVM HotSwap (debugger) | Alleen de inhoud van methoden | Vrijwel nul | Elke IDE-debugger | | DevTools-herstart | Elke klasse, elke bean, elke configuratie | Meestal 1 tot 3 seconden | `spring-boot-devtools` | | Volledige herstart | Alles | Volledige opstarttijd | Geen | | Reloading-agents | De meeste structurele wijzigingen aan klassen | Vrijwel nul | JRebel en vergelijkbare tools | Het ontwerp met twee classloaders maakt de herstart snel. Jars uit Maven Central veranderen tijdens een werksessie zelden, dus die blijven geladen in de basis-classloader, inclusief het JIT-werk dat er al op is gedaan. De projectklassen uit `target/classes` of `build/classes` staan in de restart-classloader. Bij een wijziging wordt die loader weggegooid, wordt er een nieuwe aangemaakt en wordt de `ApplicationContext` vanaf nul opnieuw opgebouwd. Daar volgen twee gevolgen uit die in de praktijk zwaar wegen: - **State gaat verloren.** In-memory caches, sessies in het geheugen en de voortgang van geplande taken verdwijnen bij elke herstart. Dat is zo bedoeld, want de context wordt volledig opnieuw opgebouwd. - **De herstart wordt getriggerd door het classpath, niet door de editor.** DevTools bewaakt de gecompileerde output. Het opslaan van een `.java`-bestand doet niets zolang de IDE of de buildtool het niet compileert. Dat tweede punt verklaart de meeste meldingen in de trant van "DevTools werkt niet". In IntelliJ IDEA moet het project worden gebouwd (Ctrl+F9 / Cmd+F9), of moet "Build project automatically" aan staan, samen met de geavanceerde instelling die automatisch compileren toestaat terwijl de applicatie draait. De [IntelliJ IDEA-documentatie over Spring Boot](https://www.jetbrains.com/help/idea/spring-boot.html) beschrijft de opties van de run configuration ("On update action", "On frame deactivation") die deze compilatiestap in gang zetten. Eclipse en Spring Tools compileren bij het opslaan, zodat de herstart daar zonder extra configuratie plaatsvindt. ## De automatische herstart afstemmen met spring.devtools-properties DevTools is te configureren via de properties onder `spring.devtools.*`. De standaardwaarden in Spring Boot 4.1.2 zijn het kennen waard, omdat ze een aantal verrassende gedragingen verklaren: de file watcher controleert **elke seconde** op wijzigingen en wacht een stilteperiode van **400 ms** af voordat hij herstart. Zo levert een compilatie van meerdere bestanden één herstart op in plaats van vijf. De onderstaande configuratie stemt DevTools af op een project dat traag compileert (grote multi-module build, netwerkschijf, Docker-volume) en statische assets serveert vanuit een buildmap van de 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 ``` Voor deze properties gelden een paar regels die vaak over het hoofd worden gezien: - `spring.devtools.restart.exclude` **vervangt** de standaardlijst (`META-INF/maven/**`, `META-INF/resources/**`, `resources/**`, `static/**`, `public/**`, `templates/**`, testklassen en build-infobestanden). `additional-exclude` **vult** die lijst juist **aan**, en dat is bijna altijd de bedoeling. - Uitgesloten resources veroorzaken geen herstart, maar worden toch actueel geserveerd, omdat DevTools caches als `spring.thymeleaf.cache` uitschakelt en `spring.web.resources.cache.period` op 0 zet. - Het triggerbestand moet op het classpath staan (`src/main/resources/.reloadtrigger`). IntelliJ IDEA Ultimate en Spring Tools kunnen het allebei na een build bijwerken. - `spring.devtools.restart.enabled=false` in `application.properties` stopt het bewaken van bestanden, maar initialiseert nog steeds de restart-classloader. Om DevTools volledig uit te schakelen, moet de system property in `main` worden gezet, vóór `SpringApplication.run`. Voor instellingen die voor alle projecten op een machine gelden, leest DevTools een globaal bestand uit `$HOME/.config/spring-boot/`, met de naam `spring-boot-devtools.properties` (of `.yaml` / `.yml`). Dat is de juiste plek voor een persoonlijke instelling van het triggerbestand die niet in de teamrepository thuishoort. Profielen worden in dit bestand niet ondersteund. ## Spring Boot LiveReload: verouderd sinds 4.1 LiveReload ververst de browser automatisch zodra een resource verandert. DevTools bevat daarvoor een LiveReload-compatibele server op poort 35729, waarmee een browserextensie verbinding maakt. In Spring Boot 4.1 staat die server standaard uit en moet hij expliciet worden ingeschakeld: ```properties # application-dev.properties # Deprecated since Spring Boot 4.1.0, no replacement planned spring.devtools.livereload.enabled=true spring.devtools.livereload.port=35729 ``` De [release notes van Spring Boot 4.1](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-4.1-Release-Notes) laten geen ruimte voor twijfel: door de afnemende populariteit en ondersteuning is de LiveReload-functie in DevTools verouderd, zonder vervanger. De browserextensies worden nauwelijks nog onderhouden, en de meeste frontends worden in 2026 gebouwd met Vite of een andere dev-server die zelf al hot module replacement biedt. > **Geen nieuwe workflow op LiveReload bouwen** > > Bestaande Thymeleaf-projecten kunnen `spring.devtools.livereload.enabled=true` voorlopig laten staan, maar een verouderde property in Spring Boot is een kandidaat voor verwijdering in een latere hoofdversie. Voor server-side gerenderde templates zorgen de cache-instellingen die DevTools toepast er al voor dat een handmatige browserverversing de nieuwste template toont, zonder de applicatie te herstarten. ## Valkuilen van de restart-classloader en de ClassCastException De meest voorkomende DevTools-bug ziet er absurd uit: `com.example.Order cannot be cast to com.example.Order`. De twee klassenamen zijn identiek omdat het om dezelfde klasse gaat, geladen door twee verschillende classloaders. De ene `Order` komt uit de restart-classloader, de andere uit de basis-classloader (of uit een eerdere restart-classloader die eigenlijk had moeten verdwijnen). Dit gebeurt doorgaans in drie situaties: 1. Een bibliotheek deserialiseert objecten met een standaard `ObjectInputStream`, die klassen via de verkeerde loader resolvet. Sessiereplicatie en sommige caches werken zo. 2. Een projectmodule wordt als jar gebruikt (een `common`-bibliotheek in een multi-module build) en belandt in de basis-classloader, terwijl de klassen die ernaar verwijzen in de restart-classloader staan. 3. Een statisch veld houdt een instantie vast die vóór de laatste herstart is aangemaakt. Voor het tweede geval leest DevTools een bestand `META-INF/spring-devtools.properties` van het classpath. De sleutels daarin verplaatsen jars met reguliere expressies tussen de twee classloaders: ```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 ``` De sleutels hoeven alleen uniek te zijn: het voorvoegsel `restart.include.` of `restart.exclude.` is wat telt. Voor het eerste geval bestaat de oplossing uit deserialiseren met Springs `ConfigurableObjectInputStream`, met `Thread.currentThread().getContextClassLoader()` als argument. Die verwijst naar de actuele restart-classloader. Blijven herstarts toch te traag, of zijn de classloaderproblemen niet op te lossen, dan noemt de documentatie een reloading-agent zoals JRebel als terugvaloptie. Zo'n agent herdefinieert klassen ter plekke in plaats van de context te herstarten. ## DevTools met Testcontainers en @RestartScope Sinds Spring Boot 3.1 kan een project ook tijdens de ontwikkeling databases en brokers via Testcontainers starten, met een launcher-klasse in `src/test/java`. Dat combineert slecht met naïeve herstarts: elke herstart zou de PostgreSQL-container afbreken en opnieuw aanmaken, wat enkele seconden kost en alle data wist. `@RestartScope`, onderdeel van de DevTools-module, lost precies dit op. Een bean met deze annotatie overleeft DevTools-herstarts. De opzet hieronder volgt de [Spring Boot-gids over development-time services](https://docs.spring.io/spring-boot/reference/features/dev-services.html), met de packagenamen van Testcontainers 2 die Spring Boot 4 gebruikt. ```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"); } } ``` De launcher hergebruikt de echte `main`-methode en voegt de configuratie toe: ```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); } } ``` De applicatie start met `./mvnw spring-boot:test-run` of `./gradlew bootTestRun`. Eén Gradle-detail maakt deze opzet echter ongemerkt onwerkzaam: met `developmentOnly` staat DevTools niet op het classpath van `bootTestRun`, waardoor codewijzigingen worden genegeerd. De afhankelijkheid moet dan naar `testAndDevelopmentOnly("org.springframework.boot:spring-boot-devtools")`. De kant van de integratietests komt aan bod in de [gids over Testcontainers met Spring Boot](https://sharpskill.dev/nl/blog/spring-boot/testcontainers-spring-boot-integration-testing). ## Remote DevTools en waarom productie verboden terrein blijft DevTools kan wijzigingen ook doorsturen naar een applicatie die elders draait, bijvoorbeeld in een container op een gedeelde ontwikkelserver. De serverkant wordt pas actief wanneer `spring.devtools.remote.secret` is ingesteld en DevTools expliciet in het archief is meeverpakt (`excludeDevtools=false` in de Maven-plugin). De client is `org.springframework.boot.devtools.RemoteSpringApplication`, die vanuit de IDE wordt gestart met de externe URL als argument. De documentatie is daarover ondubbelzinnig: Remote DevTools mag alleen over een vertrouwd netwerk of HTTPS draaien, nooit in productie, en Spring WebFlux-applicaties worden niet ondersteund. Een endpoint dat classbestanden accepteert en daarna de applicatie herstart, is per definitie een kanaal voor remote code execution. In de meeste opstellingen van 2026 levert het lokaal draaien van de applicatie tegen Testcontainers of Docker Compose-services een snellere cyclus op, zonder die blootstelling. ## Sollicitatievragen over Spring Boot DevTools In sollicitatiegesprekken over Spring Boot fungeert DevTools vaak als opstapje naar een dieper onderwerp: classloading en de levenscyclus van de application context. Dit zijn de vragen die het vaakst terugkomen, met het antwoord dat van een ervaren ontwikkelaar wordt verwacht: - **"Doet DevTools aan hot swapping of herstart het?"** Het herstart. De restart-classloader wordt weggegooid en de `ApplicationContext` opnieuw opgebouwd, terwijl de JVM en de basis-classloader blijven draaien. "Hot swap" antwoorden is de klassieke juniorfout. - **"Waarom kan DevTools veilig in de pom blijven staan?"** Door drie beschermingslagen: de scope `optional` of `developmentOnly`, uitsluiting uit de opnieuw verpakte jar en automatische deactivering bij `java -jar`. Een sterk antwoord vermeldt ook dat het forceren van `spring.devtools.restart.enabled=true` de derde laag omzeilt. - **"Waar komt `X cannot be cast to X` vandaan?"** Twee classloaders laden dezelfde klasse; op te lossen met `META-INF/spring-devtools.properties` of de context-classloader. - **"Wat gebeurt er met een in-memory cache bij een herstart?"** Die gaat verloren, tenzij de bean in `@RestartScope` staat. Deze vragen overlappen met configuratieonderwerpen. De [interviewmodule over Spring Boot DevTools](https://sharpskill.dev/nl/technologies/spring-boot/sollicitatievragen/spring-boot-devtools) sluit daarom goed aan op de [module over profielen en environment](https://sharpskill.dev/nl/technologies/spring-boot/sollicitatievragen/profiles-environment), aangezien de meeste properties hierboven in een `dev`-profiel thuishoren. De volledige vragenbank staat op de [Spring Boot-technologiepagina](https://sharpskill.dev/nl/technologies/spring-boot). ## Checklist voor de DevTools-setup in 2026 - Declareer `spring-boot-devtools` als `optional` (Maven) of `developmentOnly` (Gradle), en stap over op `testAndDevelopmentOnly` bij een Testcontainers-launcher met `bootTestRun`. - Zorg dat de IDE compileert bij opslaan of bij het verlaten van het venster: DevTools bewaakt gecompileerde klassen, geen bronbestanden. - Gebruik `spring.devtools.restart.additional-exclude` in plaats van `exclude`, zodat de standaarduitsluitingen voor statische bestanden en templates behouden blijven. - Stel een triggerbestand in via het globale `~/.config/spring-boot/spring-boot-devtools.properties` wanneer constante herstarts tijdens refactoring in de weg zitten. - Beschouw LiveReload als verouderd sinds Spring Boot 4.1.0 en vertrouw in plaats daarvan op de dev-server van de frontend of een handmatige verversing. - Annoteer ontwikkelcontainers met `@RestartScope`, zodat PostgreSQL of Kafka elke herstart overleven. - Herken `X cannot be cast to X` als een classloadersplitsing en los het op met `restart.include`-regels. Goed ingericht verandert Spring Boot DevTools de dagelijkse Java-ontwikkeling merkbaar: korte feedbackcycli, containers die herstarts overleven en een helder beeld van wat er bij het herladen achter de schermen gebeurt. Juist dat inzicht maakt in een technisch gesprek het verschil tussen een uit het hoofd geleerd antwoord en echte praktijkervaring. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/nl/blog/spring-boot/spring-boot-devtools-hot-reload-livereload