# 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. - Published: 2026-11-12 - Updated: 2026-11-12 - Author: Anthony Fillion-Maillet - Tags: spring boot devtools, hot reload, livereload, produktivität, testcontainers - Reading time: 11 min --- 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. > **Spring Boot DevTools auf einen Blick** > > 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. ```xml org.springframework.boot spring-boot-devtools true ``` In Gradle reicht eine einzige Zeile: ```kotlin // build.gradle.kts 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](https://docs.spring.io/spring-boot/reference/using/devtools.html) 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](https://www.jetbrains.com/help/idea/spring-boot.html) 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. ```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 ``` Für diese Properties gelten einige Regeln, die häufig übersehen werden: - `spring.devtools.restart.exclude` **ersetzt** die Standardliste (`META-INF/maven/**`, `META-INF/resources/**`, `resources/**`, `static/**`, `public/**`, `templates/**`, Testklassen und Build-Info-Dateien). `additional-exclude` **ergä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.cache` abschaltet und `spring.web.resources.cache.period` auf 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=false` in der `application.properties` stoppt zwar die Dateiüberwachung, initialisiert aber weiterhin den Restart-Classloader. Wer DevTools vollständig abschalten will, setzt die System-Property in der `main`-Methode vor `SpringApplication.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. ## 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: ```properties # application-dev.properties # Deprecated since Spring Boot 4.1.0, no replacement planned spring.devtools.livereload.enabled=true spring.devtools.livereload.port=35729 ``` Die [Release Notes zu Spring Boot 4.1](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-4.1-Release-Notes) 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. > **Keinen neuen Workflow auf LiveReload aufbauen** > > 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: 1. 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. 2. 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. 3. 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: ```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 ``` Die 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](https://docs.spring.io/spring-boot/reference/features/dev-services.html) und verwendet die Paketnamen von Testcontainers 2, wie sie Spring Boot 4 nutzt. ```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"); } } ``` Der Launcher verwendet die echte `main`-Methode und ergänzt lediglich die Konfiguration: ```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); } } ``` 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](https://sharpskill.dev/de/blog/spring-boot/testcontainers-spring-boot-integration-testing). ## 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 `ApplicationContext` neu 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 `optional` bzw. `developmentOnly`, Ausschluss aus dem neu gepackten JAR und automatische Deaktivierung bei `java -jar`. Eine starke Antwort erwähnt zusätzlich, dass `spring.devtools.restart.enabled=true` die dritte Ebene aushebelt. - **„Woher kommt `X cannot be cast to X`?"** Zwei Classloader laden dieselbe Klasse. Behoben wird das über `META-INF/spring-devtools.properties` oder 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](https://sharpskill.dev/de/technologies/spring-boot/interviewfragen/spring-boot-devtools) lässt sich deshalb gut mit dem [Modul zu Profilen und Environment](https://sharpskill.dev/de/technologies/spring-boot/interviewfragen/profiles-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](https://sharpskill.dev/de/technologies/spring-boot). ## Checkliste für das DevTools-Setup 2026 - `spring-boot-devtools` als `optional` (Maven) oder `developmentOnly` (Gradle) deklarieren und bei einem Testcontainers-Launcher mit `bootTestRun` auf `testAndDevelopmentOnly` umstellen. - Sicherstellen, dass die IDE beim Speichern oder beim Verlassen des Fensters kompiliert: DevTools beobachtet kompilierte Klassen, keine Quelldateien. - `spring.devtools.restart.additional-exclude` statt `exclude` verwenden, damit die Standardausschlüsse für statische Dateien und Templates erhalten bleiben. - Eine Trigger-Datei in der globalen `~/.config/spring-boot/spring-boot-devtools.properties` hinterlegen, 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 `@RestartScope` annotieren, damit PostgreSQL oder Kafka jeden Neustart überstehen. - `X cannot be cast to X` als Classloader-Aufteilung diagnostizieren und mit `restart.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. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/de/blog/spring-boot/spring-boot-devtools-hot-reload-livereload