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.

Spring Boot DevTools startet eine Java-Anwendung per Hot Reload neu

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

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

MechanismusWas sich ohne Neustart ändern lässtKosten pro ÄnderungWerkzeug
JVM HotSwap (Debugger)Nur MethodenrümpfeNahezu nullJeder IDE-Debugger
DevTools-NeustartJede Klasse, jede Bean, jede KonfigurationMeist 1 bis 3 Sekundenspring-boot-devtools
Vollständiger NeustartAllesVolle StartzeitKeines
Reloading-AgentsDie meisten Strukturänderungen an KlassenNahezu nullJRebel 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.

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.

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:

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 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 und verwendet die Paketnamen von Testcontainers 2, wie sie Spring Boot 4 nutzt.

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");
    }
}

Der Launcher verwendet die echte main-Methode und ergänzt lediglich die Konfiguration:

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);
    }
}

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 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 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-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.

Fang an zu üben!

Teste dein Wissen mit unseren Interview-Simulatoren und technischen Tests.

Tägliche Challenge

Findest du den Bug in Spring Boot?

Ein echter Codeausschnitt, ein versteckter Bug, ein Versuch pro Tag. Zum Ausprobieren ohne Konto.

Anthony Fillion-Maillet

Geschrieben von

Anthony Fillion-Maillet

Gründer von SharpSkill

Seit über 10 Jahren Fullstack-Entwickler. Er leitet SharpSkill und verantwortet alles, was hier erscheint.

Aktualisiert am 12. November 2026

Tags

#spring boot devtools
#hot reload
#livereload
#produktivität
#testcontainers

Teilen

Verwandte Artikel