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.

Spring Boot DevTools herstart een Java-applicatie met hot reload

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
<!-- 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:

build.gradle.ktskotlin
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.

MechanismeWat verandert zonder herstartKosten per wijzigingTooling
JVM HotSwap (debugger)Alleen de inhoud van methodenVrijwel nulElke IDE-debugger
DevTools-herstartElke klasse, elke bean, elke configuratieMeestal 1 tot 3 secondenspring-boot-devtools
Volledige herstartAllesVolledige opstarttijdGeen
Reloading-agentsDe meeste structurele wijzigingen aan klassenVrijwel nulJRebel 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.

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.

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:

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 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, met de packagenamen van Testcontainers 2 die Spring Boot 4 gebruikt.

src/test/java/com/example/orders/DevContainersConfiguration.javajava
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:

src/test/java/com/example/orders/TestOrdersApplication.javajava
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 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 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-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.

Begin met oefenen!

Test je kennis met onze gespreksimulatoren en technische tests.

Dagelijkse challenge

Zie jij de bug in Spring Boot?

Een echt codefragment, een verborgen bug, één poging per dag. Zonder account uit te proberen.

Anthony Fillion-Maillet

Geschreven door

Anthony Fillion-Maillet

Oprichter 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

#spring boot devtools
#hot reload
#livereload
#productiviteit
#testcontainers

Delen

Gerelateerde artikelen