Spring Boot DevTools w 2026: hot reload, LiveReload i szybsza praca programisty

Spring Boot DevTools w praktyce: jak działa hot reload oparty na restarcie, właściwości spring.devtools, przestarzały LiveReload w 4.1, ClassCastException i @RestartScope z Testcontainers.

Spring Boot DevTools: hot reload i restart aplikacji Java

Pętla „edycja, kompilacja, restart" w aplikacji webowej napisanej w Javie potrafi zabrać kilkanaście sekund przy każdej drobnej poprawce. Spring Boot DevTools skraca ten cykl do jednej, dwóch sekund, ponieważ ponownie ładuje wyłącznie kod projektu, a nie całą aplikację. Moduł jest dostępny w każdym wydaniu Spring Boot, a w linii 4.1 (aktualnie stabilna wersja 4.1.2) automatyczny restart pozostaje jego najważniejszą funkcją. LiveReload, druga dobrze znana funkcja, został natomiast oznaczony jako przestarzały.

Spring Boot DevTools w skrócie

DevTools dzieli classpath na dwa classloadery: bazowy, przechowujący biblioteki zewnętrzne, oraz restartowy, w którym znajdują się klasy projektu. Po zmianie skompilowanej klasy porzucany i tworzony od nowa jest tylko ten drugi, dlatego restart trwa znacznie krócej niż zimny start. DevTools wyłącza też cache szablonów i automatycznie dezaktywuje się w aplikacji uruchomionej jako spakowany plik java -jar.

Dodanie zależności spring-boot-devtools

Cały moduł to jeden artefakt. Kluczowy jest jego zakres: zależność nie może przeniknąć do innych modułów ani do archiwum produkcyjnego. W Mavenie służy do tego znacznik optional, w Gradle konfiguracja developmentOnly dostarczana przez plugin Spring Boot.

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>

W Gradle wystarczy jedna linia:

build.gradle.ktskotlin
dependencies {
    // developmentOnly: on the classpath for bootRun, absent from bootJar
    developmentOnly("org.springframework.boot:spring-boot-devtools")
}

Zarówno plugin Mavena, jak i Gradle domyślnie pomijają DevTools podczas przepakowywania jara. Dodatkowo moduł rozpoznaje uruchomienie „w pełni spakowanej" aplikacji (java -jar lub własny classloader launchera) i sam się wyłącza, ponieważ oficjalna dokumentacja DevTools traktuje taki start jako środowisko produkcyjne. Wymuszenie działania flagą -Dspring.devtools.restart.enabled=true jest technicznie możliwe i jest dokładnie tym, czego wdrożenie produkcyjne musi unikać.

Jak naprawdę działa hot reload w Spring Boot

Określenie „hot reload" w kontekście Spring Boot jest nieco mylące. DevTools nie podmienia bajtkodu w działającej maszynie wirtualnej. Wykonuje restart, tyle że wyjątkowo tani.

MechanizmCo zmienia się bez restartuKoszt jednej zmianyNarzędzie
JVM HotSwap (debugger)Wyłącznie ciała metodPrawie zerowyDebugger dowolnego IDE
Restart DevToolsKażda klasa, bean i konfiguracjaZwykle 1 do 3 sekundspring-boot-devtools
Pełny restartWszystkoPełny czas startuBrak
Agenty przeładowująceWiększość zmian struktury klasPrawie zerowyJRebel i podobne

O szybkości restartu decyduje architektura dwóch classloaderów. Biblioteki pobrane z Maven Central praktycznie nie zmieniają się w trakcie sesji, więc pozostają załadowane w classloaderze bazowym razem z całą pracą wykonaną już przez kompilator JIT. Klasy projektu z katalogu target/classes lub build/classes trafiają do classloadera restartowego. Każda zmiana powoduje jego porzucenie, utworzenie nowego i zbudowanie ApplicationContext od zera.

W praktyce wynikają z tego dwie istotne konsekwencje:

  • Stan aplikacji ginie. Cache w pamięci, sesje przechowywane w pamięci oraz postęp zadań harmonogramu znikają przy każdym restarcie. To zamierzone zachowanie: kontekst powstaje na nowo.
  • Restart wyzwala classpath, a nie edytor. DevTools obserwuje skompilowane pliki. Zapisanie pliku .java niczego nie zmienia, dopóki IDE lub narzędzie budujące go nie skompiluje.

Drugi punkt wyjaśnia większość zgłoszeń typu „DevTools nie działa". W IntelliJ IDEA projekt trzeba zbudować (Ctrl+F9 / Cmd+F9) albo włączyć opcję „Build project automatically" wraz z ustawieniem zaawansowanym, które pozwala na automatyczną kompilację podczas działania aplikacji. Dokumentacja IntelliJ IDEA dla Spring Boot opisuje opcje konfiguracji uruchomieniowej („On update action", „On frame deactivation"), które wyzwalają ten krok kompilacji. Eclipse i Spring Tools kompilują przy zapisie, więc restart następuje bez dodatkowej konfiguracji.

Dostrajanie automatycznego restartu właściwościami spring.devtools

DevTools konfiguruje się przez właściwości spring.devtools.*. Wartości domyślne w Spring Boot 4.1.2 warto znać, bo tłumaczą kilka zaskakujących zachowań. Obserwator plików sprawdza zmiany co 1 sekundę i odczekuje 400 ms ciszy przed restartem. Dzięki temu kompilacja kilku plików naraz kończy się jednym restartem, a nie pięcioma.

Poniższa konfiguracja dopasowuje DevTools do projektu, który kompiluje się wolno (rozbudowany build wielomodułowy, dysk sieciowy, wolumen Dockera) i serwuje zasoby statyczne z katalogu budowanego przez 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

Działanie tych właściwości opiera się na kilku regułach:

  • spring.devtools.restart.exclude zastępuje domyślną listę wykluczeń (META-INF/maven/**, META-INF/resources/**, resources/**, static/**, public/**, templates/**, klasy testowe i pliki build info). additional-exclude dopisuje pozycje do tej listy i niemal zawsze o to właśnie chodzi.
  • Wykluczone zasoby nie powodują restartu, a mimo to są serwowane w aktualnej wersji, ponieważ DevTools wyłącza cache, takie jak spring.thymeleaf.cache, i ustawia spring.web.resources.cache.period na 0.
  • Plik wyzwalający musi leżeć na classpath (src/main/resources/.reloadtrigger). IntelliJ IDEA Ultimate oraz Spring Tools potrafią go zaktualizować po zakończonym buildzie.
  • spring.devtools.restart.enabled=false w application.properties zatrzymuje obserwację plików, ale classloader restartowy nadal jest inicjalizowany. Całkowite wyłączenie DevTools wymaga ustawienia właściwości systemowej w metodzie main przed wywołaniem SpringApplication.run.

Ustawienia obowiązujące dla wszystkich projektów na danej maszynie DevTools odczytuje z globalnego pliku w katalogu $HOME/.config/spring-boot/, o nazwie spring-boot-devtools.properties (lub .yaml / .yml). To właściwe miejsce na osobiste ustawienie pliku wyzwalającego, które nie powinno trafić do repozytorium zespołu. Profile nie są w tym pliku obsługiwane.

Gotowy na rozmowy o Spring Boot?

Ćwicz z naszymi interaktywnymi symulatorami, flashcards i testami technicznymi.

LiveReload w Spring Boot: przestarzały od wersji 4.1

LiveReload odświeża przeglądarkę automatycznie po zmianie zasobu. DevTools zawiera serwer zgodny z protokołem LiveReload, nasłuchujący na porcie 35729, do którego łączy się rozszerzenie przeglądarki. W Spring Boot 4.1 serwer jest domyślnie wyłączony i trzeba go jawnie aktywować:

properties
# application-dev.properties
# Deprecated since Spring Boot 4.1.0, no replacement planned
spring.devtools.livereload.enabled=true
spring.devtools.livereload.port=35729

Informacje o wydaniu Spring Boot 4.1 mówią o tym wprost: ze względu na spadek popularności i wsparcia funkcja LiveReload w DevTools zostaje oznaczona jako przestarzała, bez planowanego zamiennika. Rozszerzenia przeglądarek są ledwie utrzymywane, a większość frontendów w 2026 roku powstaje z użyciem Vite lub innego serwera deweloperskiego, który już oferuje hot module replacement.

Nowy workflow nie powinien opierać się na LiveReload

Istniejące projekty z Thymeleaf mogą na razie zachować spring.devtools.livereload.enabled=true, ale przestarzała właściwość w Spring Boot jest kandydatem do usunięcia w kolejnej wersji głównej. W przypadku szablonów renderowanych po stronie serwera ustawienia cache narzucane przez DevTools sprawiają, że zwykłe ręczne odświeżenie przeglądarki pokazuje najnowszą wersję szablonu bez restartu aplikacji.

Pułapki classloadera restartowego i ClassCastException

Najczęstszy błąd związany z DevTools wygląda absurdalnie: com.example.Order cannot be cast to com.example.Order. Nazwy klas są identyczne, ponieważ obie klasy pochodzą z dwóch różnych classloaderów. Jeden Order został załadowany przez classloader restartowy, drugi przez bazowy (albo przez poprzedni classloader restartowy, który powinien był zostać porzucony).

Zwykle dochodzi do tego w trzech sytuacjach:

  1. Biblioteka deserializuje obiekty standardowym ObjectInputStream, który rozwiązuje klasy przez niewłaściwy classloader. Tak działa między innymi replikacja sesji i część mechanizmów cache.
  2. Moduł projektu jest używany jako jar (np. biblioteka common w buildzie wielomodułowym) i trafia do classloadera bazowego, podczas gdy klasy, które z niego korzystają, znajdują się w restartowym.
  3. Pole statyczne przechowuje instancję utworzoną przed ostatnim restartem.

Dla drugiego przypadku DevTools odczytuje z classpath plik META-INF/spring-devtools.properties. Jego klucze przenoszą jary między classloaderami na podstawie wyrażeń regularnych:

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

Klucze muszą być jedynie unikalne, znaczenie ma prefiks restart.include. lub restart.exclude.. W pierwszym przypadku rozwiązaniem jest deserializacja przy użyciu springowego ConfigurableObjectInputStream z przekazaniem Thread.currentThread().getContextClassLoader(), który wskazuje na bieżący classloader restartowy.

Jeśli restarty nadal są zbyt wolne albo problemów z classloaderami nie da się usunąć, udokumentowaną alternatywą jest agent przeładowujący, taki jak JRebel, który redefiniuje klasy w miejscu zamiast restartować kontekst.

DevTools z Testcontainers i @RestartScope

Od Spring Boot 3.1 projekt może uruchamiać bazy danych i brokery przez Testcontainers również w trakcie programowania, za pomocą klasy startowej umieszczonej w src/test/java. Naiwny restart źle się z tym łączy: każdy restart niszczyłby i odtwarzał kontener PostgreSQL, co kosztuje kilka sekund i kasuje dane.

Adnotacja @RestartScope z modułu DevTools rozwiązuje dokładnie ten problem. Bean oznaczony tą adnotacją przetrwa restarty DevTools. Poniższa konfiguracja odpowiada przewodnikowi Spring Boot po usługach czasu developmentu i używa nazw pakietów z Testcontainers 2, na którym opiera się Spring Boot 4.

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

Klasa startowa wykorzystuje prawdziwą metodę main i dokłada konfigurację kontenerów:

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

Aplikację uruchamia się poleceniem ./mvnw spring-boot:test-run lub ./gradlew bootTestRun. Jeden szczegół w Gradle po cichu psuje tę konfigurację: przy developmentOnly DevTools nie znajduje się na classpath zadania bootTestRun, więc zmiany w kodzie są ignorowane. Zależność trzeba przenieść do testAndDevelopmentOnly("org.springframework.boot:spring-boot-devtools"). Część dotyczącą testów integracyjnych omawia przewodnik po Testcontainers w Spring Boot.

Zdalne DevTools i dlaczego produkcja pozostaje poza zasięgiem

DevTools potrafi też przesyłać zmiany do aplikacji działającej gdzie indziej, na przykład w kontenerze na współdzielonym serwerze deweloperskim. Część serwerowa aktywuje się tylko wtedy, gdy ustawiono spring.devtools.remote.secret i gdy DevTools zostało jawnie dołączone do archiwum (excludeDevtools=false w pluginie Mavena). Klientem jest org.springframework.boot.devtools.RemoteSpringApplication, uruchamiany z IDE z adresem zdalnej aplikacji jako argumentem.

Dokumentacja jednoznacznie wyznacza granice: zdalne DevTools może działać wyłącznie w zaufanej sieci lub przez HTTPS, nigdy na produkcji, i nie obsługuje aplikacji Spring WebFlux. Endpoint przyjmujący pliki klas i restartujący aplikację jest z definicji kanałem zdalnego wykonania kodu. W większości konfiguracji z 2026 roku lokalne uruchomienie aplikacji z usługami Testcontainers lub Docker Compose daje szybszą pętlę bez takiego ryzyka.

Pytania rekrutacyjne o Spring Boot DevTools

DevTools pojawia się na rozmowach rekrutacyjnych ze Spring Boot jako pretekst do głębszego tematu: ładowania klas i cyklu życia kontekstu aplikacji. Najczęstsze pytania wraz z odpowiedzią oczekiwaną od doświadczonego programisty:

  • „Czy DevTools robi hot swap, czy restart?" Restart. Porzuca classloader restartowy i odbudowuje ApplicationContext, a maszyna wirtualna i classloader bazowy pozostają aktywne. Odpowiedź „hot swap" to klasyczny błąd juniora.
  • „Dlaczego DevTools można bezpiecznie zostawić w pom?" Trzy warstwy ochrony: zakres optional lub developmentOnly, wykluczenie z przepakowanego jara i automatyczna dezaktywacja przy java -jar. Mocna odpowiedź wspomina, że wymuszenie spring.devtools.restart.enabled=true omija trzecią warstwę.
  • „Skąd bierze się X cannot be cast to X?" Z dwóch classloaderów ładujących tę samą klasę. Naprawia się to przez META-INF/spring-devtools.properties lub classloader kontekstu wątku.
  • „Co dzieje się z cache w pamięci podczas restartu?" Znika, chyba że bean ma zakres @RestartScope.

Pytania te zazębiają się z tematami konfiguracji, dlatego moduł pytań rekrutacyjnych o Spring Boot DevTools dobrze uzupełnia się z modułem o profilach i środowisku, bo to właśnie profil dev jest naturalnym miejscem dla większości opisanych właściwości. Pełny zestaw pytań znajduje się na stronie technologii Spring Boot.

Lista kontrolna konfiguracji Spring Boot DevTools na 2026 rok

  • Zadeklarować spring-boot-devtools jako optional (Maven) lub developmentOnly (Gradle), a przy uruchamianiu klasy startowej Testcontainers przez bootTestRun przejść na testAndDevelopmentOnly.
  • Upewnić się, że IDE kompiluje przy zapisie lub przy utracie fokusu okna: DevTools obserwuje skompilowane klasy, a nie pliki źródłowe.
  • Używać spring.devtools.restart.additional-exclude zamiast exclude, aby zachować domyślne wykluczenia zasobów statycznych i szablonów.
  • Ustawić plik wyzwalający w globalnym ~/.config/spring-boot/spring-boot-devtools.properties, gdy ciągłe restarty przeszkadzają podczas refaktoryzacji.
  • Traktować LiveReload jako przestarzały od Spring Boot 4.1.0 i polegać zamiast niego na serwerze deweloperskim frontendu lub ręcznym odświeżeniu.
  • Oznaczać kontenery deweloperskie adnotacją @RestartScope, aby PostgreSQL czy Kafka przetrwały każdy restart.
  • Diagnozować X cannot be cast to X jako rozdzielenie classloaderów i naprawiać je wpisami restart.include.

Zacznij ćwiczyć!

Sprawdź swoją wiedzę z naszymi symulatorami rozmów i testami technicznymi.

Wyzwanie dnia

Znajdziesz błąd w Spring Boot?

Prawdziwy fragment kodu, ukryty błąd, jedna próba dziennie. Bez konta, żeby spróbować.

Anthony Fillion-Maillet

Autor:

Anthony Fillion-Maillet

Założyciel SharpSkill

Programista fullstack od ponad 10 lat. Prowadzi SharpSkill i odpowiada za wszystko, co się tu ukazuje.

Zaktualizowano 12 listopada 2026

Tagi

#spring boot devtools
#hot reload
#livereload
#produktywność programisty
#testcontainers

Udostępnij

Powiązane artykuły