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.

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.
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.
<!-- 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>In Gradle volstaat één regel:
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 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 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.
# 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=falseVoor deze properties gelden een paar regels die vaak over het hoofd worden gezien:
spring.devtools.restart.excludevervangt de standaardlijst (META-INF/maven/**,META-INF/resources/**,resources/**,static/**,public/**,templates/**, testklassen en build-infobestanden).additional-excludevult 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.cacheuitschakelt enspring.web.resources.cache.periodop 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=falseinapplication.propertiesstopt het bewaken van bestanden, maar initialiseert nog steeds de restart-classloader. Om DevTools volledig uit te schakelen, moet de system property inmainworden gezet, vóórSpringApplication.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.
Klaar om je Spring Boot gesprekken te halen?
Oefen met onze interactieve simulatoren, flashcards en technische tests.
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:
# application-dev.properties
# Deprecated since Spring Boot 4.1.0, no replacement planned
spring.devtools.livereload.enabled=true
spring.devtools.livereload.port=35729De release notes van Spring Boot 4.1 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.
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:
- Een bibliotheek deserialiseert objecten met een standaard
ObjectInputStream, die klassen via de verkeerde loader resolvet. Sessiereplicatie en sommige caches werken zo. - 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. - 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:
# 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.-]+\\.jarDe 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, met de packagenamen van Testcontainers 2 die Spring Boot 4 gebruikt.
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:
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.
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
ApplicationContextopnieuw 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
optionalofdevelopmentOnly, uitsluiting uit de opnieuw verpakte jar en automatische deactivering bijjava -jar. Een sterk antwoord vermeldt ook dat het forceren vanspring.devtools.restart.enabled=truede derde laag omzeilt. - "Waar komt
X cannot be cast to Xvandaan?" Twee classloaders laden dezelfde klasse; op te lossen metMETA-INF/spring-devtools.propertiesof de context-classloader. - "Wat gebeurt er met een in-memory cache bij een herstart?" Die gaat verloren, tenzij de bean in
@RestartScopestaat.
Deze vragen overlappen met configuratieonderwerpen. De interviewmodule over Spring Boot DevTools sluit daarom goed aan op de module over profielen en environment, aangezien de meeste properties hierboven in een dev-profiel thuishoren. De volledige vragenbank staat op de Spring Boot-technologiepagina.
Checklist voor de DevTools-setup in 2026
- Declareer
spring-boot-devtoolsalsoptional(Maven) ofdevelopmentOnly(Gradle), en stap over optestAndDevelopmentOnlybij een Testcontainers-launcher metbootTestRun. - 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-excludein plaats vanexclude, zodat de standaarduitsluitingen voor statische bestanden en templates behouden blijven. - Stel een triggerbestand in via het globale
~/.config/spring-boot/spring-boot-devtools.propertieswanneer 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 Xals een classloadersplitsing en los het op metrestart.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.
Begin met oefenen!
Test je kennis met onze gespreksimulatoren en technische tests.
Zie jij de bug in Spring Boot?
Een echt codefragment, een verborgen bug, één poging per dag. Zonder account uit te proberen.

Geschreven door
Anthony Fillion-MailletOprichter van SharpSkill
Al meer dan 10 jaar fullstack-ontwikkelaar. Hij leidt SharpSkill en staat in voor alles wat hier verschijnt.
Bijgewerkt op 12 november 2026
Tags
Delen
Gerelateerde artikelen

Testcontainers Spring Boot: pijnloze integratietests
Volledige gids voor het configureren van Testcontainers met Spring Boot 3.4. PostgreSQL, Redis en Kafka in Docker-containers voor betrouwbare, reproduceerbare integratietests.

Freelance Java Spring Boot developer opdrachten 2026: waar contracten vinden, dagtarieven en voorbereiding
Freelance Java Spring Boot developer opdrachten 2026: actuele dagtarieven (mediaan 440 EUR), beste platforms voor projecten in Nederland en Europa, voorbereiding op technische interviews.

Java Spring Boot Developer Vacatures 2026: Waar Zoeken, Salarisranges, Hoe Voorbereiden
606 actieve Spring Boot posities in september 2026. Dit artikel analyseert salarisgegevens, remote-percentages en sollicitatievoorbereding voor Java Spring Boot ontwikkelaars.