# 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. - Published: 2026-11-12 - Updated: 2026-11-12 - Author: Anthony Fillion-Maillet - Tags: spring boot devtools, hot reload, livereload, produktywność programisty, testcontainers - Reading time: 11 min --- 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 org.springframework.boot spring-boot-devtools true ``` W Gradle wystarczy jedna linia: ```kotlin // build.gradle.kts 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](https://docs.spring.io/spring-boot/reference/using/devtools.html) 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. | Mechanizm | Co zmienia się bez restartu | Koszt jednej zmiany | Narzędzie | |---|---|---|---| | JVM HotSwap (debugger) | Wyłącznie ciała metod | Prawie zerowy | Debugger dowolnego IDE | | Restart DevTools | Każda klasa, bean i konfiguracja | Zwykle 1 do 3 sekund | `spring-boot-devtools` | | Pełny restart | Wszystko | Pełny czas startu | Brak | | Agenty przeładowujące | Większość zmian struktury klas | Prawie zerowy | JRebel 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](https://www.jetbrains.com/help/idea/spring-boot.html) 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. ## 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](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-4.1-Release-Notes) 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](https://docs.spring.io/spring-boot/reference/features/dev-services.html) i używa nazw pakietów z Testcontainers 2, na którym opiera się Spring Boot 4. ```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"); } } ``` Klasa startowa wykorzystuje prawdziwą metodę `main` i dokłada konfigurację kontenerów: ```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); } } ``` 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](https://sharpskill.dev/pl/blog/spring-boot/testcontainers-spring-boot-integration-testing). ## 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](https://sharpskill.dev/pl/technologies/spring-boot/pytania-rekrutacyjne/spring-boot-devtools) dobrze uzupełnia się z [modułem o profilach i środowisku](https://sharpskill.dev/pl/technologies/spring-boot/pytania-rekrutacyjne/profiles-environment), 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](https://sharpskill.dev/pl/technologies/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`. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/pl/blog/spring-boot/spring-boot-devtools-hot-reload-livereload