# Spring Boot DevTools ปี 2026: Hot Reload, LiveReload และประสิทธิภาพการพัฒนา > บทเรียน Spring Boot DevTools สำหรับ Spring Boot 4.1: กลไกรีสตาร์ตอัตโนมัติ property spring.devtools การ deprecate LiveReload กับดัก classloader และ @RestartScope กับ Testcontainers - Published: 2026-11-12 - Updated: 2026-11-12 - Author: Anthony Fillion-Maillet - Tags: spring boot devtools, hot reload, livereload, ประสิทธิภาพการพัฒนา, testcontainers - Reading time: 11 min --- สำหรับเว็บแอปพลิเคชัน Java วงจรการแก้โค้ด build ใหม่ และรีสตาร์ตแอปพลิเคชันอาจกินเวลาหลายสิบวินาทีต่อการเปลี่ยนแปลงเพียงเล็กน้อย Spring Boot DevTools ช่วยลดวงจรนี้ให้เหลือเพียงหนึ่งถึงสองวินาที ด้วยการรีสตาร์ตเฉพาะส่วนของโค้ดที่เปลี่ยนแปลง โมดูลนี้มาพร้อมกับ Spring Boot ทุกเวอร์ชัน และใน Spring Boot 4.1 (สายเวอร์ชันเสถียรปัจจุบัน คือ 4.1.2 ณ เวลาที่เขียนบทความนี้) การรีสตาร์ตอัตโนมัติยังคงเป็นฟีเจอร์หลักด้านประสิทธิภาพการทำงาน ขณะที่ LiveReload ถูกประกาศเป็น deprecated แล้ว > **สรุป Spring Boot DevTools โดยย่อ** > > Spring Boot DevTools แบ่ง classpath ออกเป็นสอง classloader ได้แก่ base classloader สำหรับ jar จากภายนอก และ restart classloader สำหรับคลาสของโปรเจกต์ เมื่อคลาสที่คอมไพล์แล้วมีการเปลี่ยนแปลง ระบบจะทิ้งและสร้างเฉพาะ restart classloader ขึ้นใหม่ การรีสตาร์ตจึงเร็วกว่าการเริ่มระบบแบบ cold start อย่างมาก นอกจากนี้ DevTools ยังปิดการแคชเทมเพลต และปิดตัวเองโดยอัตโนมัติเมื่อแอปพลิเคชันถูกรันแบบแพ็กเกจด้วย `java -jar` ## การเพิ่ม dependency spring-boot-devtools DevTools ประกอบด้วย artifact เพียงตัวเดียว รายละเอียดสำคัญอยู่ที่ scope เพราะ dependency นี้ต้องไม่รั่วไหลไปยังโมดูลอื่นหรือเข้าไปอยู่ในไฟล์ที่ใช้ deploy บน production Maven กำหนดเรื่องนี้ด้วย `optional` ส่วน Gradle ใช้ configuration `developmentOnly` ที่มากับปลั๊กอิน Spring Boot ```xml org.springframework.boot spring-boot-devtools true ``` สำหรับ Gradle เขียนได้ในบรรทัดเดียว: ```kotlin // build.gradle.kts dependencies { // developmentOnly: on the classpath for bootRun, absent from bootJar developmentOnly("org.springframework.boot:spring-boot-devtools") } ``` ปลั๊กอินทั้งของ Maven และ Gradle จะตัด DevTools ออกจาก jar ที่ผ่านการ repackage โดยค่าเริ่มต้น นอกจากนี้ DevTools ยังตรวจจับการรันแบบ "แพ็กเกจสมบูรณ์" (`java -jar` หรือ launcher ที่ใช้ classloader แบบกำหนดเอง) แล้วปิดตัวเอง เนื่องจาก[เอกสารอ้างอิง DevTools อย่างเป็นทางการ](https://docs.spring.io/spring-boot/reference/using/devtools.html)ถือว่าการรันลักษณะนี้คือสภาพแวดล้อม production การบังคับเปิดด้วย `-Dspring.devtools.restart.enabled=true` ทำได้ก็จริง แต่นั่นคือสิ่งที่การ deploy บน production ต้องหลีกเลี่ยงโดยเด็ดขาด ## กลไกที่แท้จริงของ hot reload ใน Spring Boot คำว่า "hot reload ของ Spring Boot" อาจทำให้เข้าใจคลาดเคลื่อนได้เล็กน้อย DevTools ไม่ได้สลับ bytecode ภายใน JVM ที่กำลังทำงานอยู่ แต่ใช้วิธี **รีสตาร์ต** ที่มีต้นทุนต่ำ | กลไก | สิ่งที่เปลี่ยนได้โดยไม่ต้องรีสตาร์ต | ต้นทุนต่อการเปลี่ยนแปลง | เครื่องมือ | |---|---|---|---| | JVM HotSwap (debugger) | เฉพาะเนื้อหาภายใน method | แทบเป็นศูนย์ | debugger ของ IDE ใดก็ได้ | | การรีสตาร์ตของ DevTools | คลาส bean และการตั้งค่าทุกอย่าง | ปกติ 1 ถึง 3 วินาที | `spring-boot-devtools` | | รีสตาร์ตเต็มรูปแบบ | ทุกอย่าง | เวลาเริ่มระบบทั้งหมด | ไม่มี | | Reloading agent | การเปลี่ยนโครงสร้างคลาสส่วนใหญ่ | แทบเป็นศูนย์ | JRebel และเครื่องมือที่คล้ายกัน | การออกแบบแบบสอง classloader คือสิ่งที่ทำให้การรีสตาร์ตรวดเร็ว jar จาก Maven Central แทบไม่เปลี่ยนแปลงระหว่างการพัฒนา จึงถูกโหลดค้างไว้ใน base classloader พร้อมกับผลการปรับแต่งของ JIT ที่ทำไปแล้ว ส่วนคลาสของโปรเจกต์จาก `target/classes` หรือ `build/classes` จะอยู่ใน restart classloader เมื่อมีการเปลี่ยนแปลง loader นี้จะถูกทิ้ง มีการสร้าง loader ใหม่ และ `ApplicationContext` จะถูกสร้างขึ้นใหม่ทั้งหมด ในทางปฏิบัติมีผลกระทบสำคัญสองประการ: - **สถานะ (state) จะหายไป** แคชในหน่วยความจำ session ที่เก็บไว้ในหน่วยความจำ และความคืบหน้าของ scheduled task จะหายไปทุกครั้งที่รีสตาร์ต ซึ่งเป็นพฤติกรรมที่ตั้งใจออกแบบไว้ เพราะ context ถูกสร้างใหม่ทั้งหมด - **การรีสตาร์ตถูกกระตุ้นจาก classpath ไม่ใช่จาก editor** DevTools เฝ้าดูผลลัพธ์จากการคอมไพล์ การบันทึกไฟล์ `.java` จะไม่มีผลใดๆ จนกว่า IDE หรือเครื่องมือ build จะคอมไพล์ไฟล์นั้น ประเด็นที่สองอธิบายสาเหตุของปัญหา "DevTools ไม่ทำงาน" ได้เกือบทั้งหมด ใน IntelliJ IDEA ต้องสั่ง build โปรเจกต์ (Ctrl+F9 / Cmd+F9) หรือเปิด "Build project automatically" ร่วมกับการตั้งค่าขั้นสูงที่อนุญาตให้ auto-make ขณะแอปพลิเคชันกำลังทำงาน [เอกสาร Spring Boot ของ IntelliJ IDEA](https://www.jetbrains.com/help/idea/spring-boot.html)อธิบายตัวเลือกของ run configuration ("On update action", "On frame deactivation") ที่ใช้กระตุ้นขั้นตอนการคอมไพล์นี้ ส่วน Eclipse และ Spring Tools จะคอมไพล์ทันทีที่บันทึกไฟล์ การรีสตาร์ตจึงเกิดขึ้นได้โดยไม่ต้องตั้งค่าเพิ่มเติม ## ปรับแต่งการรีสตาร์ตอัตโนมัติด้วย property spring.devtools DevTools ปรับแต่งได้ผ่าน property กลุ่ม `spring.devtools.*` ค่าเริ่มต้นใน Spring Boot 4.1.2 เป็นสิ่งที่ควรรู้ เพราะช่วยอธิบายพฤติกรรมที่น่าประหลาดใจหลายอย่าง ตัวเฝ้าดูไฟล์จะตรวจสอบ (polling) ทุก **1 วินาที** และรอช่วงเงียบ **400 ms** ก่อนรีสตาร์ต เพื่อให้การคอมไพล์ที่แตะหลายไฟล์ทำให้เกิดการรีสตาร์ตเพียงครั้งเดียวแทนที่จะเป็นห้าครั้ง การตั้งค่าด้านล่างปรับ DevTools ให้เหมาะกับโปรเจกต์ที่คอมไพล์ช้า (build แบบหลายโมดูลขนาดใหญ่, network drive หรือ Docker volume) และให้บริการไฟล์ static จากโฟลเดอร์ 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 ``` property เหล่านี้มีกฎสำคัญดังนี้: - `spring.devtools.restart.exclude` จะ **แทนที่** รายการค่าเริ่มต้น (`META-INF/maven/**`, `META-INF/resources/**`, `resources/**`, `static/**`, `public/**`, `templates/**`, คลาสทดสอบ และไฟล์ build info) ส่วน `additional-exclude` จะ **เพิ่ม** เข้าไปในรายการ ซึ่งแทบทุกครั้งคือสิ่งที่ต้องการจริงๆ - resource ที่ถูกยกเว้นจะไม่ทำให้แอปพลิเคชันรีสตาร์ต แต่ยังคงถูกให้บริการในเวอร์ชันล่าสุด เพราะ DevTools ปิดแคชอย่าง `spring.thymeleaf.cache` และตั้งค่า `spring.web.resources.cache.period` เป็น 0 - trigger file ต้องอยู่บน classpath (`src/main/resources/.reloadtrigger`) ทั้ง IntelliJ IDEA Ultimate และ Spring Tools สามารถอัปเดตไฟล์นี้หลังการ build ได้ - `spring.devtools.restart.enabled=false` ใน `application.properties` จะหยุดการเฝ้าดูไฟล์ แต่ยังคงสร้าง restart classloader อยู่ หากต้องการปิด DevTools อย่างสมบูรณ์ ต้องกำหนด system property ใน method `main` ก่อนเรียก `SpringApplication.run` สำหรับการตั้งค่าที่ใช้กับทุกโปรเจกต์บนเครื่องเดียวกัน DevTools จะอ่านไฟล์ส่วนกลางจาก `$HOME/.config/spring-boot/` ชื่อ `spring-boot-devtools.properties` (หรือ `.yaml` / `.yml`) ซึ่งเป็นตำแหน่งที่เหมาะสำหรับการตั้งค่า trigger file ส่วนตัวที่ไม่ควร commit เข้า repository ของทีม ไฟล์นี้ไม่รองรับ profile ## LiveReload ใน Spring Boot: deprecated ตั้งแต่ 4.1 LiveReload ทำหน้าที่รีเฟรชเบราว์เซอร์อัตโนมัติเมื่อ resource มีการเปลี่ยนแปลง DevTools ฝังเซิร์ฟเวอร์ที่รองรับ LiveReload ไว้ที่พอร์ต 35729 และส่วนขยายของเบราว์เซอร์จะเชื่อมต่อเข้ามา ใน Spring Boot 4.1 เซิร์ฟเวอร์นี้ถูกปิดไว้โดยค่าเริ่มต้น และต้องเปิดใช้งานอย่างชัดเจน: ```properties # application-dev.properties # Deprecated since Spring Boot 4.1.0, no replacement planned spring.devtools.livereload.enabled=true spring.devtools.livereload.port=35729 ``` [Release notes ของ Spring Boot 4.1](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-4.1-Release-Notes)ระบุไว้อย่างตรงไปตรงมาว่า "Given its decrease in popularity and support, the LiveReload feature in Devtools is deprecated with no replacement." ส่วนขยายของเบราว์เซอร์แทบไม่ได้รับการดูแลแล้ว และ frontend ส่วนใหญ่ในปี 2026 สร้างด้วย Vite หรือ dev server อื่นที่มี hot module replacement อยู่แล้ว > **ไม่ควรสร้าง workflow ใหม่บน LiveReload** > > โปรเจกต์ Thymeleaf ที่มีอยู่เดิมยังคงใช้ `spring.devtools.livereload.enabled=true` ต่อไปได้ในระยะนี้ แต่ property ที่ถูก deprecated ใน Spring Boot มีโอกาสถูกลบออกในเวอร์ชันหลักถัดไป สำหรับเทมเพลตที่เรนเดอร์ฝั่งเซิร์ฟเวอร์ การตั้งค่าแคชที่ DevTools กำหนดไว้ก็เพียงพอแล้ว การรีเฟรชเบราว์เซอร์ด้วยตนเองจะแสดงเทมเพลตล่าสุดได้ทันทีโดยไม่ต้องรีสตาร์ตแอปพลิเคชัน ## กับดักของ restart classloader และ ClassCastException บั๊กที่พบบ่อยที่สุดของ DevTools ดูเหมือนไร้เหตุผล: `com.example.Order cannot be cast to com.example.Order` ชื่อคลาสทั้งสองเหมือนกันทุกตัวอักษร เพราะทั้งสองคลาสมาจากคนละ classloader `Order` ตัวหนึ่งถูกโหลดโดย restart classloader ส่วนอีกตัวถูกโหลดโดย base classloader (หรือโดย restart classloader รุ่นก่อนหน้าที่ควรถูกทิ้งไปแล้ว) ปัญหานี้มักเกิดขึ้นในสามสถานการณ์: 1. ไลบรารีทำ deserialization ของออบเจกต์ด้วย `ObjectInputStream` มาตรฐาน ซึ่ง resolve คลาสผ่าน loader ที่ไม่ถูกต้อง การทำ session replication และแคชบางประเภทมีพฤติกรรมแบบนี้ 2. โมดูลของโปรเจกต์ถูกใช้งานในรูปแบบ jar (เช่น ไลบรารี `common` ใน build แบบหลายโมดูล) จึงไปอยู่ใน base classloader ขณะที่คลาสที่อ้างอิงถึงโมดูลนั้นอยู่ใน restart loader 3. field แบบ static เก็บ instance ที่ถูกสร้างก่อนการรีสตาร์ตครั้งล่าสุด สำหรับกรณีที่สอง DevTools จะอ่านไฟล์ `META-INF/spring-devtools.properties` จาก classpath โดย key ในไฟล์นี้ใช้ regular expression เพื่อย้าย jar ระหว่าง classloader ทั้งสอง: ```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 แต่ละตัวเพียงแค่ต้องไม่ซ้ำกัน สิ่งที่มีผลคือ prefix `restart.include.` หรือ `restart.exclude.` สำหรับกรณีแรก วิธีแก้คือทำ deserialization ด้วย `ConfigurableObjectInputStream` ของ Spring แล้วส่ง `Thread.currentThread().getContextClassLoader()` ซึ่งชี้ไปยัง restart loader ปัจจุบันเสมอ หากการรีสตาร์ตยังช้าเกินไป หรือไม่สามารถแก้ปัญหา classloader ได้ ทางเลือกสำรองที่มีระบุในเอกสารคือ reloading agent อย่าง JRebel ซึ่งนิยามคลาสใหม่ในที่เดิมแทนการรีสตาร์ต context ## DevTools ร่วมกับ Testcontainers และ @RestartScope ตั้งแต่ Spring Boot 3.1 โปรเจกต์สามารถเริ่มฐานข้อมูลและ message broker ผ่าน Testcontainers ได้ในช่วงพัฒนา โดยใช้คลาส launcher ใน `src/test/java` แต่การผสมผสานนี้จะทำงานได้ไม่ดีหากรีสตาร์ตแบบตรงไปตรงมา เพราะการรีสตาร์ตแต่ละครั้งจะทำลายและสร้าง container ของ PostgreSQL ขึ้นใหม่ ซึ่งเสียเวลาหลายวินาทีและล้างข้อมูลทั้งหมด `@RestartScope` ซึ่งอยู่ในโมดูล DevTools ถูกออกแบบมาเพื่อแก้ปัญหานี้โดยเฉพาะ bean ที่ติด annotation นี้จะคงอยู่ข้ามการรีสตาร์ตของ DevTools การตั้งค่าด้านล่างอ้างอิงตาม[คู่มือ development-time services ของ Spring Boot](https://docs.spring.io/spring-boot/reference/features/dev-services.html) โดยใช้ชื่อ package ของ Testcontainers 2 ที่ 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 นำ method `main` ตัวจริงกลับมาใช้ และเพิ่มการตั้งค่าข้างต้นเข้าไป: ```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); } } ``` แอปพลิเคชันเริ่มทำงานด้วย `./mvnw spring-boot:test-run` หรือ `./gradlew bootTestRun` มีรายละเอียดหนึ่งของ Gradle ที่ทำให้การตั้งค่านี้พังโดยไม่มีสัญญาณเตือน คือเมื่อใช้ `developmentOnly` DevTools จะไม่อยู่บน classpath ของ `bootTestRun` การเปลี่ยนแปลงโค้ดจึงถูกเพิกเฉย ต้องย้าย dependency ไปเป็น `testAndDevelopmentOnly("org.springframework.boot:spring-boot-devtools")` ส่วนของ integration test สำหรับการตั้งค่านี้อธิบายไว้ใน[คู่มือ Testcontainers สำหรับ Spring Boot](https://sharpskill.dev/th/blog/spring-boot/testcontainers-spring-boot-integration-testing) ## Remote DevTools และเหตุผลที่ต้องห้ามใช้บน production DevTools ยังสามารถส่งการเปลี่ยนแปลงไปยังแอปพลิเคชันที่รันอยู่ที่อื่นได้ เช่น ใน container บนเซิร์ฟเวอร์พัฒนาที่ใช้ร่วมกัน ฝั่งเซิร์ฟเวอร์ระยะไกลจะเปิดใช้งานก็ต่อเมื่อกำหนด `spring.devtools.remote.secret` และแพ็กเกจ DevTools เข้าไปในไฟล์อย่างชัดเจน (`excludeDevtools=false` บนปลั๊กอิน Maven) ฝั่ง client คือ `org.springframework.boot.devtools.RemoteSpringApplication` ซึ่งรันจาก IDE โดยส่ง URL ปลายทางเป็นอาร์กิวเมนต์ เอกสารกำหนดขอบเขตไว้อย่างชัดเจน: remote DevTools ต้องรันบนเครือข่ายที่เชื่อถือได้หรือผ่าน HTTPS เท่านั้น ห้ามใช้บน production เด็ดขาด และไม่รองรับแอปพลิเคชัน Spring WebFlux endpoint ที่รับไฟล์คลาสแล้วรีสตาร์ตแอปพลิเคชันนั้น โดยธรรมชาติแล้วก็คือช่องทาง remote code execution ในการตั้งค่าส่วนใหญ่ของปี 2026 การรันแอปพลิเคชันบนเครื่องตัวเองร่วมกับบริการจาก Testcontainers หรือ Docker Compose ให้วงจรการพัฒนาที่เร็วกว่า โดยไม่มีความเสี่ยงด้านการเปิดเผยระบบเช่นนั้น ## คำถามสัมภาษณ์งานเกี่ยวกับ Spring Boot DevTools ในการสัมภาษณ์งานด้าน Spring Boot มักใช้ DevTools เป็นทางเข้าสู่หัวข้อที่ลึกกว่า นั่นคือการโหลดคลาสและวงจรชีวิตของ application context ต่อไปนี้คือคำถามที่พบบ่อยที่สุด พร้อมคำตอบที่นักพัฒนาที่มีประสบการณ์ควรให้ได้: - **"DevTools ทำ hot swap หรือรีสตาร์ต?"** รีสตาร์ต DevTools ทิ้ง restart classloader และสร้าง `ApplicationContext` ขึ้นใหม่ ขณะที่ JVM และ base classloader ยังคงทำงานอยู่ การตอบว่า "hot swap" เป็นข้อผิดพลาดคลาสสิกของนักพัฒนาระดับจูเนียร์ - **"ทำไมการคง DevTools ไว้ใน pom จึงปลอดภัย?"** มีการป้องกันสามชั้น ได้แก่ scope แบบ `optional` หรือ `developmentOnly` การตัดออกจาก jar ที่ผ่านการ repackage และการปิดตัวเองอัตโนมัติเมื่อรันด้วย `java -jar` คำตอบที่ดีจะกล่าวถึงด้วยว่าการบังคับ `spring.devtools.restart.enabled=true` จะข้ามการป้องกันชั้นที่สาม - **"ข้อผิดพลาด `X cannot be cast to X` มาจากไหน?"** เกิดจาก classloader สองตัวโหลดคลาสเดียวกัน แก้ไขได้ด้วย `META-INF/spring-devtools.properties` หรือ context classloader - **"แคชในหน่วยความจำจะเป็นอย่างไรเมื่อรีสตาร์ต?"** แคชจะหายไป ยกเว้น bean นั้นอยู่ใน `@RestartScope` คำถามเหล่านี้คาบเกี่ยวกับหัวข้อการตั้งค่า ดังนั้น[โมดูลคำถามสัมภาษณ์ Spring Boot DevTools](https://sharpskill.dev/th/technologies/spring-boot/interview-questions/spring-boot-devtools)จึงควรศึกษาควบคู่กับ[โมดูล profiles และ environment](https://sharpskill.dev/th/technologies/spring-boot/interview-questions/profiles-environment) เพราะ profile `dev` คือที่ที่ property ส่วนใหญ่ข้างต้นควรอยู่ คลังคำถามทั้งหมดอยู่ที่[หน้าเทคโนโลยี Spring Boot](https://sharpskill.dev/th/technologies/spring-boot) ## เช็กลิสต์การตั้งค่า Spring Boot DevTools สำหรับปี 2026 - ประกาศ `spring-boot-devtools` เป็น `optional` (Maven) หรือ `developmentOnly` (Gradle) และเปลี่ยนเป็น `testAndDevelopmentOnly` เมื่อรัน launcher ของ Testcontainers ด้วย `bootTestRun` - ตรวจสอบให้ IDE คอมไพล์เมื่อบันทึกไฟล์หรือเมื่อหน้าต่างเสียโฟกัส เพราะ DevTools เฝ้าดูคลาสที่คอมไพล์แล้ว ไม่ใช่ไฟล์ซอร์สโค้ด - ใช้ `spring.devtools.restart.additional-exclude` แทน `exclude` เพื่อคงข้อยกเว้นค่าเริ่มต้นสำหรับไฟล์ static และเทมเพลตไว้ - กำหนด trigger file ในไฟล์ส่วนกลาง `~/.config/spring-boot/spring-boot-devtools.properties` เมื่อการรีสตาร์ตบ่อยครั้งระหว่าง refactor เริ่มเป็นอุปสรรค - ถือว่า LiveReload เป็นฟีเจอร์ deprecated ตั้งแต่ Spring Boot 4.1.0 และหันไปใช้ dev server ของ frontend หรือรีเฟรชด้วยตนเองแทน - ติด annotation `@RestartScope` ให้กับ container สำหรับการพัฒนา เพื่อให้ PostgreSQL หรือ Kafka คงอยู่ข้ามการรีสตาร์ตแต่ละครั้ง - วินิจฉัยข้อผิดพลาด `X cannot be cast to X` ว่าเป็นปัญหา classloader แยกกัน และแก้ไขด้วยรายการ `restart.include` เมื่อกำหนด scope ของ dependency ถูกต้อง ตั้งค่าให้ IDE คอมไพล์อัตโนมัติ และปรับแต่ง property เพียงไม่กี่ตัวอย่างเหมาะสม Spring Boot DevTools จะทำให้วงจรการพัฒนา Java ตอบสนองได้รวดเร็วขึ้นอย่างเห็นได้ชัด ความเข้าใจในกลไกสอง classloader เบื้องหลังยังเป็นข้อได้เปรียบที่แท้จริงเมื่อต้องเผชิญคำถามสัมภาษณ์เรื่องการโหลดคลาสและ application context --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/th/blog/spring-boot/spring-boot-devtools-hot-reload-livereload