# Spring Boot DevTools 2026: Hot Reload, LiveReload, dan Produktivitas Developer > Tutorial Spring Boot DevTools untuk Spring Boot 4.1: cara kerja restart otomatis, properti spring.devtools, LiveReload yang deprecated, jebakan classloader, dan @RestartScope dengan Testcontainers. - Published: 2026-11-12 - Updated: 2026-11-12 - Author: Anthony Fillion-Maillet - Tags: spring boot devtools, hot reload, livereload, produktivitas developer, testcontainers - Reading time: 11 min --- Siklus ubah kode, build ulang, lalu restart aplikasi web Java bisa memakan waktu puluhan detik setiap kali. Spring Boot DevTools memangkas siklus tersebut menjadi satu atau dua detik dengan hanya me-restart bagian kode yang berubah. Modul ini selalu dirilis bersama Spring Boot, dan di Spring Boot 4.1 (lini stabil saat ini, versi 4.1.2 ketika artikel ini ditulis) fitur restart otomatis tetap menjadi andalan utama, sementara LiveReload kini berstatus deprecated. > **Ringkasan Spring Boot DevTools** > > Spring Boot DevTools membagi classpath ke dalam dua classloader: base classloader untuk jar pihak ketiga dan restart classloader untuk kelas milik proyek. Ketika sebuah kelas hasil kompilasi berubah, hanya restart classloader yang dibuang dan dibuat ulang, sehingga restart jauh lebih cepat dibandingkan cold start. DevTools juga menonaktifkan cache template dan otomatis mati ketika aplikasi dijalankan sebagai paket `java -jar`. ## Menambahkan dependensi spring-boot-devtools DevTools hanya terdiri dari satu artefak. Hal yang perlu diperhatikan adalah scope-nya: dependensi ini tidak boleh ikut terbawa ke modul lain maupun ke arsip produksi. Maven mengaturnya lewat `optional`, sedangkan Gradle memakai konfigurasi `developmentOnly` yang disediakan plugin Spring Boot. ```xml org.springframework.boot spring-boot-devtools true ``` Padanannya di Gradle cukup satu baris: ```kotlin // build.gradle.kts dependencies { // developmentOnly: on the classpath for bootRun, absent from bootJar developmentOnly("org.springframework.boot:spring-boot-devtools") } ``` Plugin Maven maupun Gradle secara default mengecualikan DevTools dari jar hasil repackage. Selain itu, DevTools mendeteksi peluncuran yang "terpaket penuh" (`java -jar` atau launcher dengan classloader khusus) lalu menonaktifkan dirinya, karena [dokumentasi resmi DevTools](https://docs.spring.io/spring-boot/reference/using/devtools.html) menganggap peluncuran semacam itu sebagai lingkungan produksi. Memaksanya aktif dengan `-Dspring.devtools.restart.enabled=true` memang bisa dilakukan, dan justru itulah yang wajib dihindari pada deployment produksi. ## Cara kerja hot reload Spring Boot yang sebenarnya Istilah "hot reload Spring Boot" sebenarnya agak menyesatkan. DevTools tidak menukar bytecode di dalam JVM yang sedang berjalan. Yang terjadi adalah **restart**, tetapi restart yang murah. | Mekanisme | Yang bisa berubah tanpa restart | Biaya per perubahan | Tooling | |---|---|---|---| | JVM HotSwap (debugger) | Hanya isi method | Hampir nol | Debugger IDE apa pun | | Restart DevTools | Kelas, bean, dan konfigurasi apa pun | Biasanya 1 sampai 3 detik | `spring-boot-devtools` | | Restart penuh | Semuanya | Seluruh waktu startup | Tidak ada | | Reloading agent | Sebagian besar perubahan struktur kelas | Hampir nol | JRebel dan sejenisnya | Desain dua classloader inilah yang membuat restart berlangsung cepat. Jar dari Maven Central jarang berubah selama sesi pengembangan, sehingga tetap dimuat di base classloader beserta hasil optimasi JIT yang sudah dilakukan. Kelas proyek dari `target/classes` atau `build/classes` berada di restart classloader. Setiap perubahan membuang loader tersebut, membuat yang baru, lalu `ApplicationContext` dibangun ulang dari awal. Ada dua konsekuensi penting dalam praktik: - **State hilang.** Cache di memori, sesi yang disimpan di memori, dan progres scheduled task akan hilang setiap kali restart. Ini memang disengaja karena context dibangun ulang. - **Restart dipicu oleh classpath, bukan oleh editor.** DevTools mengawasi hasil kompilasi. Menyimpan file `.java` tidak berpengaruh apa pun sampai IDE atau build tool mengompilasinya. Poin kedua menjelaskan sebagian besar keluhan "DevTools tidak berfungsi". Di IntelliJ IDEA, proyek harus di-build (Ctrl+F9 / Cmd+F9), atau opsi "Build project automatically" harus diaktifkan bersama pengaturan lanjutan yang mengizinkan auto-make saat aplikasi berjalan. [Dokumentasi Spring Boot di IntelliJ IDEA](https://www.jetbrains.com/help/idea/spring-boot.html) menjelaskan opsi run configuration ("On update action", "On frame deactivation") yang memicu langkah kompilasi ini. Eclipse dan Spring Tools mengompilasi saat file disimpan, sehingga restart berjalan tanpa konfigurasi tambahan. ## Mengatur restart otomatis dengan properti spring.devtools DevTools dapat dikonfigurasi melalui properti `spring.devtools.*`. Nilai default di Spring Boot 4.1.2 penting untuk dipahami karena menjelaskan beberapa perilaku yang kerap mengejutkan: file watcher melakukan polling setiap **1 detik** dan menunggu masa tenang selama **400 ms** sebelum restart, sehingga kompilasi yang menyentuh banyak file hanya menghasilkan satu restart, bukan lima. Konfigurasi berikut menyesuaikan DevTools untuk proyek yang proses kompilasinya lambat (build multi-modul berukuran besar, network drive, atau volume Docker) dan yang menyajikan aset statis dari folder build 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 ``` Beberapa aturan berlaku untuk properti di atas: - `spring.devtools.restart.exclude` **menggantikan** daftar default (`META-INF/maven/**`, `META-INF/resources/**`, `resources/**`, `static/**`, `public/**`, `templates/**`, kelas test, dan file build info). `additional-exclude` **menambahkan** ke daftar tersebut, dan hampir selalu inilah yang sebenarnya diinginkan. - Resource yang dikecualikan tidak memicu restart, tetapi tetap disajikan dalam versi terbaru karena DevTools menonaktifkan cache seperti `spring.thymeleaf.cache` dan menyetel `spring.web.resources.cache.period` ke 0. - Trigger file harus berada di classpath (`src/main/resources/.reloadtrigger`). IntelliJ IDEA Ultimate dan Spring Tools sama-sama mampu memperbaruinya setelah build. - `spring.devtools.restart.enabled=false` di `application.properties` menghentikan pengawasan file, tetapi restart classloader tetap diinisialisasi. Untuk mematikan DevTools sepenuhnya, system property harus disetel di method `main` sebelum `SpringApplication.run`. Untuk pengaturan yang berlaku bagi semua proyek di satu mesin, DevTools membaca file global di `$HOME/.config/spring-boot/` bernama `spring-boot-devtools.properties` (atau `.yaml` / `.yml`). Lokasi ini tepat untuk pengaturan trigger file pribadi yang tidak seharusnya di-commit ke repositori tim. Profile tidak didukung di file tersebut. ## LiveReload Spring Boot: deprecated sejak 4.1 LiveReload me-refresh browser secara otomatis ketika sebuah resource berubah. DevTools menyertakan server yang kompatibel dengan LiveReload di port 35729, lalu ekstensi browser terhubung ke server tersebut. Di Spring Boot 4.1, server ini nonaktif secara default dan harus dinyalakan secara eksplisit: ```properties # application-dev.properties # Deprecated since Spring Boot 4.1.0, no replacement planned spring.devtools.livereload.enabled=true spring.devtools.livereload.port=35729 ``` [Catatan rilis Spring Boot 4.1](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-4.1-Release-Notes) menyatakannya dengan lugas: "Given its decrease in popularity and support, the LiveReload feature in Devtools is deprecated with no replacement." Ekstensi browsernya nyaris tidak lagi dipelihara, dan sebagian besar frontend di tahun 2026 dibangun dengan Vite atau dev server lain yang sudah menyediakan hot module replacement. > **Hindari membangun workflow baru di atas LiveReload** > > Proyek Thymeleaf yang sudah ada masih dapat mempertahankan `spring.devtools.livereload.enabled=true` untuk sementara, tetapi properti yang deprecated di Spring Boot berpotensi dihapus pada versi mayor berikutnya. Untuk template yang dirender di server, pengaturan cache yang diterapkan DevTools sudah cukup: refresh browser secara manual akan menampilkan template terbaru tanpa perlu me-restart aplikasi. ## Jebakan restart classloader dan ClassCastException Bug DevTools yang paling umum terlihat tidak masuk akal: `com.example.Order cannot be cast to com.example.Order`. Nama kedua kelas identik karena keduanya berasal dari dua classloader berbeda. Satu `Order` dimuat oleh restart classloader, sementara yang lain dimuat oleh base classloader (atau oleh restart classloader sebelumnya yang seharusnya sudah dibuang). Masalah ini biasanya muncul dalam tiga situasi: 1. Sebuah library melakukan deserialisasi objek dengan `ObjectInputStream` standar, yang me-resolve kelas melalui loader yang salah. Replikasi sesi dan beberapa jenis cache melakukan hal ini. 2. Sebuah modul proyek dikonsumsi sebagai jar (misalnya library `common` dalam build multi-modul) sehingga berakhir di base classloader, sedangkan kelas yang mereferensikannya berada di restart loader. 3. Sebuah field static menyimpan instance yang dibuat sebelum restart terakhir. Untuk kasus kedua, DevTools membaca file `META-INF/spring-devtools.properties` dari classpath. Key di dalamnya memindahkan jar antara kedua classloader menggunakan regular expression: ```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 ``` Key cukup bersifat unik: yang menentukan adalah prefiks `restart.include.` atau `restart.exclude.`. Untuk kasus pertama, solusinya adalah melakukan deserialisasi dengan `ConfigurableObjectInputStream` milik Spring dan meneruskan `Thread.currentThread().getContextClassLoader()`, yang selalu menunjuk ke restart loader saat ini. Apabila restart masih terlalu lambat atau masalah classloader tidak dapat diatasi, alternatif yang terdokumentasi adalah reloading agent seperti JRebel, yang mendefinisikan ulang kelas di tempat alih-alih me-restart context. ## DevTools bersama Testcontainers dan @RestartScope Sejak Spring Boot 3.1, sebuah proyek dapat menjalankan database dan message broker melalui Testcontainers pada saat pengembangan, menggunakan kelas launcher di `src/test/java`. Kombinasi ini bermasalah jika restart dilakukan secara naif: setiap restart akan menghancurkan lalu membuat ulang container PostgreSQL, yang memakan beberapa detik dan menghapus seluruh data. `@RestartScope`, yang berada di modul DevTools, dirancang tepat untuk masalah ini. Bean yang diberi anotasi tersebut akan bertahan melewati restart DevTools. Konfigurasi di bawah mengikuti [panduan development-time services Spring Boot](https://docs.spring.io/spring-boot/reference/features/dev-services.html), dengan nama package Testcontainers 2 yang digunakan oleh 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"); } } ``` Launcher memakai ulang method `main` yang asli lalu menambahkan konfigurasi tersebut: ```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); } } ``` Aplikasi dijalankan dengan `./mvnw spring-boot:test-run` atau `./gradlew bootTestRun`. Ada satu detail Gradle yang diam-diam merusak setup ini: dengan `developmentOnly`, DevTools tidak berada di classpath `bootTestRun`, sehingga perubahan kode diabaikan. Dependensi perlu dipindahkan ke `testAndDevelopmentOnly("org.springframework.boot:spring-boot-devtools")`. Sisi integration test dari setup ini dibahas dalam [panduan Testcontainers untuk Spring Boot](https://sharpskill.dev/id/blog/spring-boot/testcontainers-spring-boot-integration-testing). ## Remote DevTools dan alasan produksi tetap terlarang DevTools juga mampu mengirim perubahan ke aplikasi yang berjalan di tempat lain, misalnya di dalam container pada server pengembangan bersama. Sisi server remote hanya aktif jika `spring.devtools.remote.secret` disetel dan DevTools secara eksplisit dimasukkan ke dalam arsip (`excludeDevtools=false` pada plugin Maven). Kliennya adalah `org.springframework.boot.devtools.RemoteSpringApplication`, yang dijalankan dari IDE dengan URL remote sebagai argumen. Dokumentasi menetapkan batasannya dengan tegas: remote DevTools hanya boleh berjalan di jaringan tepercaya atau melalui HTTPS, tidak pernah di produksi, dan tidak mendukung aplikasi Spring WebFlux. Endpoint yang menerima file kelas lalu me-restart aplikasi pada dasarnya merupakan saluran remote code execution. Pada sebagian besar setup di tahun 2026, menjalankan aplikasi secara lokal dengan layanan Testcontainers atau Docker Compose memberikan siklus yang lebih cepat tanpa risiko eksposur tersebut. ## Pertanyaan wawancara seputar Spring Boot DevTools Dalam wawancara Spring Boot, DevTools sering dijadikan pintu masuk ke topik yang lebih dalam: classloading dan siklus hidup application context. Berikut pertanyaan yang paling sering muncul, beserta jawaban yang diharapkan dari developer berpengalaman: - **"Apakah DevTools melakukan hot swap atau restart?"** Restart. DevTools membuang restart classloader dan membangun ulang `ApplicationContext`, sementara JVM dan base classloader tetap hidup. Menjawab "hot swap" adalah kesalahan klasik developer junior. - **"Mengapa DevTools aman dibiarkan di pom?"** Ada tiga lapis perlindungan: scope `optional` atau `developmentOnly`, pengecualian dari jar hasil repackage, dan penonaktifan otomatis saat `java -jar`. Jawaban yang kuat juga menyebutkan bahwa memaksa `spring.devtools.restart.enabled=true` akan melewati lapis ketiga. - **"Dari mana asal error `X cannot be cast to X`?"** Dua classloader memuat kelas yang sama. Solusinya adalah `META-INF/spring-devtools.properties` atau context classloader. - **"Apa yang terjadi pada cache di memori saat restart?"** Cache tersebut hilang, kecuali bean-nya berada dalam `@RestartScope`. Pertanyaan-pertanyaan ini bersinggungan dengan topik konfigurasi, sehingga [modul pertanyaan wawancara Spring Boot DevTools](https://sharpskill.dev/id/technologies/spring-boot/pertanyaan-wawancara/spring-boot-devtools) cocok dipelajari bersama [modul profiles dan environment](https://sharpskill.dev/id/technologies/spring-boot/pertanyaan-wawancara/profiles-environment), karena profile `dev` adalah tempat sebagian besar properti di atas seharusnya diletakkan. Bank soal lengkap tersedia di [halaman teknologi Spring Boot](https://sharpskill.dev/id/technologies/spring-boot). ## Checklist setup Spring Boot DevTools untuk 2026 - Deklarasikan `spring-boot-devtools` sebagai `optional` (Maven) atau `developmentOnly` (Gradle), lalu beralih ke `testAndDevelopmentOnly` saat menjalankan launcher Testcontainers dengan `bootTestRun`. - Pastikan IDE mengompilasi saat file disimpan atau saat jendela kehilangan fokus, karena DevTools mengawasi kelas hasil kompilasi, bukan file sumber. - Gunakan `spring.devtools.restart.additional-exclude` alih-alih `exclude`, agar pengecualian default untuk file statis dan template tetap terjaga. - Tetapkan trigger file di file global `~/.config/spring-boot/spring-boot-devtools.properties` ketika restart yang terus-menerus selama refactoring mulai mengganggu. - Perlakukan LiveReload sebagai fitur deprecated sejak Spring Boot 4.1.0, dan andalkan dev server frontend atau refresh manual sebagai gantinya. - Beri anotasi `@RestartScope` pada container pengembangan agar PostgreSQL atau Kafka bertahan di setiap restart. - Diagnosis error `X cannot be cast to X` sebagai pemisahan classloader, lalu perbaiki dengan entri `restart.include`. Dengan scope dependensi yang benar, IDE yang mengompilasi otomatis, dan beberapa properti yang disetel dengan cermat, Spring Boot DevTools mengubah siklus pengembangan Java menjadi jauh lebih responsif. Memahami mekanisme dua classloader di baliknya juga memberi keunggulan nyata saat menghadapi pertanyaan wawancara tentang classloading dan application context. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/id/blog/spring-boot/spring-boot-devtools-hot-reload-livereload