Spring Boot DevTools – szybszy development

TL;DR: Spring Boot DevTools to game-changer dla produktywności developera. Automatyczne restarty aplikacji, live reload w przeglądarce, zdalne debugging – wszystko out-of-the-box. Dodaj jedną zależność i zapomnij o manual restartach.

Spring Boot DevTools – szybszy development

Ile razy dziennie restartujesz aplikację Spring Boot podczas developmentu? 50 razy? 100? A gdybym Ci powiedział, że możesz zredukować to do zera i dodatkowo mieć live reload w przeglądarce? Spring Boot DevTools to narzędzie, które zmieni Twój sposób pracy już dziś.

Dlaczego to ważne

Średni developer traci 2-3 godziny dziennie na czekanie podczas restartów aplikacji. W projekcie enterprise z dużą ilością dependencies startup może trwać 30-60 sekund. DevTools redukuje to do 1-2 sekund, co oznacza oszczędność czasu i znacznie lepszy flow podczas kodowania.

Co się nauczysz:

  • Jak skonfigurować DevTools w projekcie Maven i Gradle
  • Czym różni się automatic restart od live reload
  • Jak używać remote debugging i remote update
  • Jakie pliki są monitorowane i jak to skonfigurować
  • Troubleshooting typowych problemów z DevTools
Wymagania wstępne: Podstawowa znajomość Spring Boot, umiejętność tworzenia prostych aplikacji. Przydatna znajomość Maven lub Gradle.

Instalacja DevTools

Dodanie DevTools to jedna linia w pliku build. Ważne: dependency ma scope `optional` aby nie trafiło do production.

Maven (pom.xml)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

Gradle (build.gradle)

dependencies {
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
}
Gradle ma specjalną konfigurację `developmentOnly` która automatycznie excluduje DevTools z production JARs. W Maven używamy `optional=true` dla tego samego efektu.

Automatic Restart – koniec z manual restartami

Po dodaniu DevTools każda zmiana w kodzie Java automatycznie triggeruje restart aplikacji. Nie pełny restart JVM, tylko reload Application Context – dlatego jest tak szybki.

Jak to działa

DevTools monitoruje zmiany w classpath i automatycznie restartuje Application Context gdy wykryje modyfikację pliku. Wykorzystuje dwa classloadery:
– **Base classloader** – ładuje niezmienne biblioteki (dependencies)
– **Restart classloader** – ładuje kod aplikacji (to co się zmienia)

@RestController
public class HelloController {
    
    @GetMapping("/hello")
    public String hello() {
        return "Hello DevTools!"; // Zmiana tutaj = auto restart
    }
}
Pro tip: Restart działa tylko gdy zmiany są skompilowane. W IntelliJ IDEA włącz „Build project automatically” w Settings → Build, Execution, Deployment → Compiler.

Live Reload – nie odświeżaj przeglądarki ręcznie

DevTools ma wbudowany LiveReload server który automatycznie odświeża przeglądarkę gdy zmieni się plik HTML, CSS lub JavaScript.

Konfiguracja LiveReload

1. **Zainstaluj rozszerzenie LiveReload** w przeglądarce (Chrome/Firefox)
2. **Włącz rozszerzenie** na localhost
3. **DevTools automatycznie startuje** LiveReload server na porcie 35729

# application.properties - opcjonalne customization
spring.devtools.livereload.enabled=true
spring.devtools.livereload.port=35729

Teraz każda zmiana w template Thymeleaf, CSS czy JS automatycznie odświeży przeglądarkę bez utraty stanu aplikacji.

LiveReload to jak asystent który non-stop obserwuje Twoje pliki i mówi przeglądarce „hej, coś się zmieniło, odśwież się”. Nie musisz pamiętać o F5.

Konfiguracja monitorowania plików

Domyślnie DevTools monitoruje standardowe lokalizacje, ale możesz to dostosować:

# application.properties
# Dodatkowe foldery do monitorowania
spring.devtools.restart.additional-paths=/path/to/folder

# Pliki/foldery do ignorowania
spring.devtools.restart.exclude=static/**,public/**

# Całkowite wyłączenie restart
spring.devtools.restart.enabled=false
Monitorowane domyślnieIgnorowane domyślnie
/src/main/java/src/main/resources/static
/src/main/resources/src/main/resources/public
/src/test/java/src/main/resources/templates (tylko zmiany content)
/src/test/resources/META-INF/maven, /META-INF/resources

Remote Development – rozwój na zdalnym serwerze

DevTools pozwala na remote development – możesz rozwijać aplikację lokalnie, a zmiany synchronizować z aplikacją running na remote server.

Konfiguracja Remote DevTools

# Na remote server - application.properties
spring.devtools.remote.secret=mysecret
// Lokalne uruchomienie remote client
public class RemoteApplication {
    public static void main(String[] args) {
        System.setProperty("spring.devtools.remote.secret", "mysecret");
        RemoteSpringApplication.run(RemoteApplication.class, 
            "http://remote-server:8080");
    }
}
Uwaga: Remote DevTools NIE powinno być używane w production. To narzędzie development, nie deployment tool.

Troubleshooting częstych problemów

Problem: Automatic restart nie działa

**Przyczyny:**
– IDE nie kompiluje automatycznie zmian
– Zmiany w plikach które są excluded
– DevTools dependency ma złe scope

**Rozwiązanie:**

# IntelliJ IDEA - włącz auto-compilation
Settings → Build → Compiler → Build project automatically

# Eclipse - auto-compilation jest domyślnie włączone
# Sprawdź czy Project → Build Automatically jest zaznaczone

Problem: LiveReload nie łączy się

**Checklist:**
– [ ] Rozszerzenie LiveReload zainstalowane w przeglądarce
– [ ] Rozszerzenie włączone dla localhost
– [ ] Port 35729 nie jest blokowany przez firewall
– [ ] Aplikacja została zrestartowana po dodaniu DevTools

Błąd początkujących: Zapominanie o instalacji rozszerzenia LiveReload w przeglądarce. DevTools ma server, ale przeglądarka musi „wiedzieć” żeby się z nim łączyć.

Performance tips

DevTools jest szybki, ale można go zoptymalizować:

# Wyłącz restart dla plików które się często zmieniają ale nie wymagają restartu
spring.devtools.restart.exclude=static/**,templates/**

# Zwiększ poll interval jeśli masz problemy z performance
spring.devtools.restart.poll-interval=2s
spring.devtools.restart.quiet-period=1s
Pro tip: Jeśli pracujesz głównie z frontend (HTML/CSS/JS), wyłącz automatic restart i zostaw tylko LiveReload. Będzie jeszcze szybciej.
Czy DevTools wpływa na performance aplikacji?

W development environment – minimalnie. DevTools ma overhead związany z monitorowaniem plików, ale to kilka ms. W production DevTools się nie uruchamia (dzięki optional dependency).

Czy mogę używać DevTools z external Tomcat?

Tak, ale automatic restart nie będzie działać. LiveReload będzie działać normalnie. DevTools najlepiej sprawdza się z embedded server (domyślny w Spring Boot).

LiveReload działa tylko z HTML czy też z REST API?

LiveReload odświeża przeglądarkę, więc działa z wszystkim co wyświetla przeglądarka. Jeśli testujesz REST API przez frontend – będzie działać. Dla czystego API testing użyj automatic restart.

Czy DevTools zachowuje stan aplikacji podczas restart?

Nie, to pełny restart Application Context. Session data, cache, in-memory data giną. Dla zachowania stanu użyj profili development z persistent storage (H2 database z file storage).

Mogę wyłączyć DevTools na production przez properties?

DevTools automatycznie się wyłącza gdy aplikacja jest uruchomiona z packaged JAR (java -jar). Dodatkowo możesz ustawić spring.devtools.restart.enabled=false w production properties.

🚀 Zadanie dla Ciebie

Stwórz prosty projekt Spring Boot z:

  • REST controllerem zwracającym aktualny czas
  • Thymeleaf template wyświetlającym ten czas
  • CSS z prostym stylingiem

Dodaj DevTools i przetestuj:

  • Zmianę w controller – czy automatic restart działa?
  • Zmianę w CSS – czy LiveReload odświeża przeglądarkę?
  • Ile czasu trwa restart vs cold start aplikacji?

Przydatne zasoby

**Czy DevTools zmieniło Twój workflow development?** Podziel się w komentarzach swoimi tipami i trikami – szczególnie interesują mnie niestandardowe konfiguracje i integration z różnymi IDE.

Zostaw komentarz

Twój adres e-mail nie zostanie opublikowany. Wymagane pola są oznaczone *

Przewijanie do góry