Spring Boot DevTools 2026: Hot Reload, LiveReload und schnellere Entwicklung
Spring Boot DevTools 2026 richtig einrichten: automatischer Neustart, Restart-Classloader, LiveReload-Abkündigung in 4.1, @RestartScope mit Testcontainers und typische Interviewfragen.

Wer an einer Spring-Boot-Anwendung arbeitet, verbringt einen erstaunlich großen Teil des Tages mit Warten: Code ändern, neu bauen, Anwendung stoppen, wieder starten, Browser aktualisieren. Spring Boot DevTools verkürzt genau diesen Zyklus auf ein bis zwei Sekunden, indem nur der Teil der Anwendung neu geladen wird, der sich tatsächlich geändert hat. Mit Spring Boot 4.1 (aktuell in Version 4.1.2) bleibt der automatische Neustart das Herzstück des Moduls, während LiveReload offiziell als veraltet markiert wurde. Dieser Leitfaden zeigt, wie DevTools 2026 sauber eingerichtet wird, wo die typischen Stolperfallen liegen und welche Fragen dazu in Vorstellungsgesprächen auftauchen.
DevTools teilt den Classpath auf zwei Classloader auf: einen Basis-Classloader für die Bibliotheken von Drittanbietern und einen Restart-Classloader für die Klassen des eigenen Projekts. Ändert sich eine kompilierte Klasse, wird nur der Restart-Classloader verworfen und neu erzeugt. Dadurch ist ein Neustart deutlich schneller als ein Kaltstart. Zusätzlich deaktiviert DevTools das Template-Caching und schaltet sich in paketierten java -jar-Anwendungen selbst ab.
Die Abhängigkeit spring-boot-devtools korrekt einbinden
DevTools besteht aus einem einzigen Artefakt. Entscheidend ist nicht die Abhängigkeit selbst, sondern ihr Gültigkeitsbereich: Das Modul darf weder in andere Module durchsickern noch im Produktionsarchiv landen. In Maven geschieht das über optional, in Gradle über die Konfiguration developmentOnly, die das Spring-Boot-Plugin bereitstellt.
<!-- 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 reicht eine einzige Zeile:
dependencies {
// developmentOnly: on the classpath for bootRun, absent from bootJar
developmentOnly("org.springframework.boot:spring-boot-devtools")
}Sowohl das Maven- als auch das Gradle-Plugin schließen DevTools standardmäßig aus dem neu gepackten JAR aus. Darüber hinaus erkennt DevTools einen „vollständig paketierten" Start (java -jar oder ein eigener Launcher-Classloader) und deaktiviert sich in diesem Fall selbst, denn laut offizieller DevTools-Referenz gilt ein solcher Start als Produktionsbetrieb. Mit -Dspring.devtools.restart.enabled=true lässt sich das zwar erzwingen, doch genau das sollte in einer Produktionsumgebung niemals passieren.
Wie der Hot Reload in Spring Boot tatsächlich funktioniert
Der Begriff „Spring Boot Hot Reload" ist streng genommen irreführend. DevTools tauscht keinen Bytecode in einer laufenden JVM aus, sondern führt einen Neustart durch, allerdings einen sehr günstigen. Ein Vergleich der verfügbaren Mechanismen macht den Unterschied deutlich:
| Mechanismus | Was sich ohne Neustart ändern lässt | Kosten pro Änderung | Werkzeug |
|---|---|---|---|
| JVM HotSwap (Debugger) | Nur Methodenrümpfe | Nahezu null | Jeder IDE-Debugger |
| DevTools-Neustart | Jede Klasse, jede Bean, jede Konfiguration | Meist 1 bis 3 Sekunden | spring-boot-devtools |
| Vollständiger Neustart | Alles | Volle Startzeit | Keines |
| Reloading-Agents | Die meisten Strukturänderungen an Klassen | Nahezu null | JRebel und Vergleichbare |
Die Geschwindigkeit verdankt DevTools dem Zwei-Classloader-Modell. JARs aus Maven Central ändern sich während einer Entwicklungssitzung praktisch nie und bleiben deshalb im Basis-Classloader geladen, inklusive der bereits erledigten JIT-Optimierungen. Die Projektklassen aus target/classes oder build/classes liegen dagegen im Restart-Classloader. Bei einer Änderung wird dieser Loader verworfen, ein neuer angelegt und der ApplicationContext von Grund auf neu aufgebaut.
Daraus ergeben sich zwei Konsequenzen, die im Alltag eine Rolle spielen:
- Der Zustand geht verloren. In-Memory-Caches, im Speicher gehaltene Sessions und der Fortschritt geplanter Tasks verschwinden bei jedem Neustart. Das ist gewollt, denn der Kontext wird komplett neu erzeugt.
- Der Neustart wird vom Classpath ausgelöst, nicht vom Editor. DevTools beobachtet die kompilierten Dateien. Das Speichern einer
.java-Datei bewirkt nichts, solange IDE oder Build-Tool sie nicht kompilieren.
Der zweite Punkt erklärt die meisten Meldungen der Art „DevTools funktioniert nicht". In IntelliJ IDEA muss das Projekt gebaut werden (Strg+F9 bzw. Cmd+F9), oder die Option „Build project automatically" wird zusammen mit der erweiterten Einstellung aktiviert, die das automatische Kompilieren bei laufender Anwendung erlaubt. Die IntelliJ-IDEA-Dokumentation zu Spring Boot beschreibt die passenden Optionen der Run-Configuration („On update action", „On frame deactivation"), die diesen Kompilierschritt anstoßen. Eclipse und Spring Tools kompilieren beim Speichern, dort startet die Anwendung ohne weitere Konfiguration neu.
Den automatischen Neustart über spring.devtools-Properties feinjustieren
DevTools lässt sich über die Properties unter spring.devtools.* konfigurieren. Die Standardwerte in Spring Boot 4.1.2 erklären einige Verhaltensweisen, die zunächst überraschen: Der Datei-Watcher prüft jede Sekunde auf Änderungen und wartet eine Ruhephase von 400 ms, bevor er neu startet. So erzeugt ein Kompiliervorgang, der mehrere Dateien betrifft, genau einen Neustart statt fünf.
Die folgende Konfiguration passt DevTools an ein Projekt an, das langsam kompiliert (großer Multi-Module-Build, Netzlaufwerk, Docker-Volume) und statische Assets aus einem Frontend-Build-Ordner ausliefert.
# 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=falseFür diese Properties gelten einige Regeln, die häufig übersehen werden:
spring.devtools.restart.excludeersetzt die Standardliste (META-INF/maven/**,META-INF/resources/**,resources/**,static/**,public/**,templates/**, Testklassen und Build-Info-Dateien).additional-excludeergänzt sie dagegen, was in fast allen Fällen die eigentliche Absicht ist.- Ausgeschlossene Ressourcen lösen keinen Neustart aus, werden aber trotzdem aktuell ausgeliefert, weil DevTools Caches wie
spring.thymeleaf.cacheabschaltet undspring.web.resources.cache.periodauf 0 setzt. - Die Trigger-Datei muss auf dem Classpath liegen (
src/main/resources/.reloadtrigger). IntelliJ IDEA Ultimate und Spring Tools können sie nach einem Build automatisch aktualisieren. spring.devtools.restart.enabled=falsein derapplication.propertiesstoppt zwar die Dateiüberwachung, initialisiert aber weiterhin den Restart-Classloader. Wer DevTools vollständig abschalten will, setzt die System-Property in dermain-Methode vorSpringApplication.run.
Für Einstellungen, die für alle Projekte auf einem Rechner gelten sollen, liest DevTools eine globale Datei aus $HOME/.config/spring-boot/ mit dem Namen spring-boot-devtools.properties (alternativ .yaml oder .yml). Dort gehört beispielsweise eine persönliche Trigger-Datei-Einstellung hin, die nicht ins Team-Repository eingecheckt werden soll. Profile werden in dieser Datei nicht unterstützt.
Bereit für deine Spring Boot-Interviews?
Übe mit unseren interaktiven Simulatoren, Flashcards und technischen Tests.
Spring Boot LiveReload: seit 4.1 als veraltet markiert
LiveReload aktualisiert den Browser automatisch, sobald sich eine Ressource ändert. DevTools bringt dafür einen LiveReload-kompatiblen Server auf Port 35729 mit, mit dem sich eine Browser-Erweiterung verbindet. In Spring Boot 4.1 ist dieser Server standardmäßig ausgeschaltet und muss explizit aktiviert werden:
# application-dev.properties
# Deprecated since Spring Boot 4.1.0, no replacement planned
spring.devtools.livereload.enabled=true
spring.devtools.livereload.port=35729Die Release Notes zu Spring Boot 4.1 sind in diesem Punkt eindeutig: Aufgrund sinkender Verbreitung und nachlassender Unterstützung gilt die LiveReload-Funktion in DevTools als veraltet, ein Ersatz ist nicht vorgesehen. Die zugehörigen Browser-Erweiterungen werden kaum noch gepflegt, und die meisten Frontends entstehen 2026 mit Vite oder einem anderen Dev-Server, der Hot Module Replacement ohnehin mitbringt.
Bestehende Thymeleaf-Projekte können spring.devtools.livereload.enabled=true vorerst beibehalten. Eine als veraltet markierte Property ist in Spring Boot jedoch ein Kandidat für die Entfernung in einer späteren Hauptversion. Bei serverseitig gerenderten Templates sorgen die von DevTools gesetzten Cache-Einstellungen ohnehin dafür, dass ein manuelles Neuladen im Browser die aktuelle Template-Version zeigt, ohne die Anwendung neu zu starten.
Fallstricke des Restart-Classloaders und die ClassCastException
Der häufigste DevTools-Fehler wirkt auf den ersten Blick absurd: com.example.Order cannot be cast to com.example.Order. Beide Klassennamen sind identisch, weil es sich tatsächlich um dieselbe Klasse handelt, nur geladen von zwei verschiedenen Classloadern. Eine Order-Instanz stammt aus dem Restart-Classloader, die andere aus dem Basis-Classloader oder aus einem früheren Restart-Classloader, der eigentlich hätte verworfen werden sollen.
In der Praxis tritt das Problem in drei Konstellationen auf:
- Eine Bibliothek deserialisiert Objekte mit einem gewöhnlichen
ObjectInputStream, der Klassen über den falschen Loader auflöst. Session-Replikation und manche Caches arbeiten auf diese Weise. - Ein Projektmodul wird als JAR eingebunden (etwa eine
common-Bibliothek in einem Multi-Module-Build) und landet im Basis-Classloader, während die Klassen, die es verwenden, im Restart-Classloader liegen. - Ein statisches Feld hält eine Instanz, die vor dem letzten Neustart erzeugt wurde.
Für den zweiten Fall liest DevTools eine Datei META-INF/spring-devtools.properties vom Classpath. Deren Schlüssel verschieben JARs per regulärem Ausdruck zwischen den beiden Classloadern:
# 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.-]+\\.jarDie Schlüssel müssen lediglich eindeutig sein, entscheidend ist das Präfix restart.include. bzw. restart.exclude.. Für den ersten Fall besteht die Lösung darin, mit Springs ConfigurableObjectInputStream zu deserialisieren und Thread.currentThread().getContextClassLoader() zu übergeben. Dieser Aufruf liefert den aktuell gültigen Restart-Classloader.
Bleiben die Neustarts trotz allem zu langsam oder lassen sich die Classloader-Probleme nicht beheben, nennt die Dokumentation einen Reloading-Agent wie JRebel als Ausweg. Ein solcher Agent definiert Klassen an Ort und Stelle neu, statt den Kontext neu zu starten.
DevTools mit Testcontainers und @RestartScope kombinieren
Seit Spring Boot 3.1 lassen sich Datenbanken und Message Broker auch zur Entwicklungszeit über Testcontainers starten, und zwar über eine Launcher-Klasse in src/test/java. Mit naiven Neustarts verträgt sich das schlecht: Jeder Neustart würde den PostgreSQL-Container zerstören und neu anlegen, was mehrere Sekunden kostet und sämtliche Daten löscht.
Die Annotation @RestartScope aus dem DevTools-Modul löst genau dieses Problem. Eine damit versehene Bean überdauert DevTools-Neustarts. Das folgende Setup orientiert sich am Leitfaden zu Development-Time-Services in Spring Boot und verwendet die Paketnamen von Testcontainers 2, wie sie Spring Boot 4 nutzt.
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");
}
}Der Launcher verwendet die echte main-Methode und ergänzt lediglich die Konfiguration:
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);
}
}Gestartet wird die Anwendung mit ./mvnw spring-boot:test-run oder ./gradlew bootTestRun. Ein Gradle-Detail macht dieses Setup allerdings unbemerkt wirkungslos: Mit developmentOnly befindet sich DevTools nicht auf dem Classpath von bootTestRun, sodass Codeänderungen schlicht ignoriert werden. Die Abhängigkeit muss deshalb auf testAndDevelopmentOnly("org.springframework.boot:spring-boot-devtools") umgestellt werden. Die Integrationstest-Seite dieses Aufbaus behandelt der Leitfaden zu Testcontainers mit Spring Boot.
Remote DevTools und warum die Produktion tabu bleibt
DevTools kann Änderungen auch an eine Anwendung übertragen, die an einem anderen Ort läuft, etwa in einem Container auf einem gemeinsam genutzten Entwicklungsserver. Die Serverseite wird nur aktiv, wenn spring.devtools.remote.secret gesetzt ist und DevTools ausdrücklich ins Archiv gepackt wurde (excludeDevtools=false im Maven-Plugin). Als Client dient org.springframework.boot.devtools.RemoteSpringApplication, das aus der IDE mit der entfernten URL als Argument gestartet wird.
Die Dokumentation zieht hier klare Grenzen: Remote DevTools darf nur über ein vertrauenswürdiges Netzwerk oder HTTPS laufen, niemals in Produktion, und Spring-WebFlux-Anwendungen werden nicht unterstützt. Ein Endpunkt, der Klassendateien entgegennimmt und die Anwendung daraufhin neu startet, ist konstruktionsbedingt ein Kanal für Remote Code Execution. In den meisten Setups des Jahres 2026 ist es schneller und sicherer, die Anwendung lokal gegen Testcontainers oder Docker-Compose-Services laufen zu lassen.
Typische Interviewfragen zu Spring Boot DevTools
In Vorstellungsgesprächen dient DevTools häufig als Einstieg in ein tieferes Thema: Classloading und den Lebenszyklus des Application Context. Die folgenden Fragen tauchen regelmäßig auf, jeweils mit der Antwort, die von erfahrenen Entwicklerinnen und Entwicklern erwartet wird:
- „Macht DevTools Hot Swapping oder einen Neustart?" Einen Neustart. Der Restart-Classloader wird verworfen und der
ApplicationContextneu aufgebaut, während JVM und Basis-Classloader weiterlaufen. Die Antwort „Hot Swap" ist der klassische Anfängerfehler. - „Warum kann DevTools gefahrlos in der pom.xml bleiben?" Wegen drei Schutzebenen: Scope
optionalbzw.developmentOnly, Ausschluss aus dem neu gepackten JAR und automatische Deaktivierung beijava -jar. Eine starke Antwort erwähnt zusätzlich, dassspring.devtools.restart.enabled=truedie dritte Ebene aushebelt. - „Woher kommt
X cannot be cast to X?" Zwei Classloader laden dieselbe Klasse. Behoben wird das überMETA-INF/spring-devtools.propertiesoder den Kontext-Classloader. - „Was passiert bei einem Neustart mit einem In-Memory-Cache?" Er geht verloren, es sei denn, die Bean liegt im
@RestartScope.
Diese Fragen überschneiden sich mit Konfigurationsthemen. Das Interviewmodul zu Spring Boot DevTools lässt sich deshalb gut mit dem Modul zu Profilen und Environment kombinieren, da die meisten der oben genannten Properties in ein dev-Profil gehören. Der vollständige Fragenkatalog findet sich auf der Spring-Boot-Technologieseite.
Checkliste für das DevTools-Setup 2026
spring-boot-devtoolsalsoptional(Maven) oderdevelopmentOnly(Gradle) deklarieren und bei einem Testcontainers-Launcher mitbootTestRunauftestAndDevelopmentOnlyumstellen.- Sicherstellen, dass die IDE beim Speichern oder beim Verlassen des Fensters kompiliert: DevTools beobachtet kompilierte Klassen, keine Quelldateien.
spring.devtools.restart.additional-excludestattexcludeverwenden, damit die Standardausschlüsse für statische Dateien und Templates erhalten bleiben.- Eine Trigger-Datei in der globalen
~/.config/spring-boot/spring-boot-devtools.propertieshinterlegen, wenn ständige Neustarts beim Refactoring stören. - LiveReload seit Spring Boot 4.1.0 als veraltet behandeln und stattdessen auf den Frontend-Dev-Server oder ein manuelles Neuladen setzen.
- Entwicklungscontainer mit
@RestartScopeannotieren, damit PostgreSQL oder Kafka jeden Neustart überstehen. X cannot be cast to Xals Classloader-Aufteilung diagnostizieren und mitrestart.include-Einträgen beheben.
Richtig konfiguriert, verwandelt Spring Boot DevTools den Entwicklungsalltag mit Java spürbar: kurze Rückkopplungsschleifen, Container, die Neustarts überleben, und ein klares Verständnis davon, was beim Neuladen im Hintergrund passiert. Genau dieses Verständnis unterscheidet in technischen Interviews eine auswendig gelernte Antwort von echter Praxiserfahrung.
Fang an zu üben!
Teste dein Wissen mit unseren Interview-Simulatoren und technischen Tests.
Findest du den Bug in Spring Boot?
Ein echter Codeausschnitt, ein versteckter Bug, ein Versuch pro Tag. Zum Ausprobieren ohne Konto.

Geschrieben von
Anthony Fillion-MailletGründer von SharpSkill
Seit über 10 Jahren Fullstack-Entwickler. Er leitet SharpSkill und verantwortet alles, was hier erscheint.
Aktualisiert am 12. November 2026
Tags
Teilen
Verwandte Artikel

Testcontainers Spring Boot: schmerzfreie Integrationstests
Vollständiger Leitfaden zur Konfiguration von Testcontainers mit Spring Boot 3.4. PostgreSQL, Redis und Kafka in Docker-Containern für zuverlässige, reproduzierbare Integrationstests.

Freelance Java Spring Boot Entwickler Jobs 2026: Wo Aufträge finden, Tagessätze und Vorbereitung
Freelance Java Spring Boot Entwickler Aufträge 2026: aktuelle Tagessätze (Median 440 EUR), beste Plattformen für Projekte in Deutschland und Europa, Interview-Vorbereitung.

Java Spring Boot Entwickler Jobs 2026: Wo suchen, Gehaltsrahmen, wie vorbereiten
606 aktive Spring Boot Positionen im September 2026. Dieser Artikel analysiert Gehaltsdaten, Remote-Anteile und Interviewvorbereitung für Java Spring Boot Entwickler.