Spring Boot DevTools ปี 2026: Hot Reload, LiveReload และประสิทธิภาพการพัฒนา

บทเรียน Spring Boot DevTools สำหรับ Spring Boot 4.1: กลไกรีสตาร์ตอัตโนมัติ property spring.devtools การ deprecate LiveReload กับดัก classloader และ @RestartScope กับ Testcontainers

Spring Boot DevTools ทำ hot reload รีสตาร์ตแอปพลิเคชัน Java

สำหรับเว็บแอปพลิเคชัน 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
<!-- 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>

สำหรับ Gradle เขียนได้ในบรรทัดเดียว:

build.gradle.ktskotlin
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 อย่างเป็นทางการถือว่าการรันลักษณะนี้คือสภาพแวดล้อม 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อธิบายตัวเลือกของ 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

พร้อมที่จะพิชิตการสัมภาษณ์ Spring Boot แล้วหรือยังครับ?

ฝึกฝนด้วยตัวจำลองแบบโต้ตอบ, flashcards และแบบทดสอบเทคนิคครับ

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ระบุไว้อย่างตรงไปตรงมาว่า "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 โดยใช้ชื่อ package ของ Testcontainers 2 ที่ 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");
    }
}

launcher นำ method main ตัวจริงกลับมาใช้ และเพิ่มการตั้งค่าข้างต้นเข้าไป:

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

แอปพลิเคชันเริ่มทำงานด้วย ./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

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จึงควรศึกษาควบคู่กับโมดูล profiles และ environment เพราะ profile dev คือที่ที่ property ส่วนใหญ่ข้างต้นควรอยู่ คลังคำถามทั้งหมดอยู่ที่หน้าเทคโนโลยี 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

เริ่มฝึกซ้อมเลย!

ทดสอบความรู้ของคุณด้วยตัวจำลองสัมภาษณ์และแบบทดสอบเทคนิคครับ

ชาเลนจ์ประจำวัน

คุณหาบั๊กใน Spring Boot เจอไหม

โค้ดจริงหนึ่งชิ้น บั๊กที่ซ่อนอยู่หนึ่งจุด วันละหนึ่งครั้ง ลองได้โดยไม่ต้องมีบัญชี

Anthony Fillion-Maillet

เขียนโดย

Anthony Fillion-Maillet

ผู้ก่อตั้ง SharpSkill

เป็นนักพัฒนาฟูลสแตกมากว่า 10 ปี ดูแล SharpSkill และรับผิดชอบทุกสิ่งที่เผยแพร่ที่นี่

อัปเดตเมื่อ 12 พฤศจิกายน 2569

แท็ก

#spring boot devtools
#hot reload
#livereload
#ประสิทธิภาพการพัฒนา
#testcontainers

แชร์

บทความที่เกี่ยวข้อง

การทดสอบ Integration ของ Spring Boot ด้วย Testcontainers, PostgreSQL, Redis และ Kafka

Testcontainers Spring Boot: การทดสอบ Integration ที่ไร้ความยุ่งยาก

คู่มือฉบับสมบูรณ์สำหรับการตั้งค่า Testcontainers ร่วมกับ Spring Boot 3.4 PostgreSQL, Redis และ Kafka ในคอนเทนเนอร์ Docker เพื่อการทดสอบ Integration ที่เชื่อถือได้และทำซ้ำได้

Freelance Java Spring Boot developer jobs 2026

งาน Freelance Developer Java Spring Boot 2026: หาสัญญาที่ไหน อัตราค่าจ้างรายวัน และการเตรียมตัว

คู่มือครบถ้วนสำหรับ developer freelance Java Spring Boot ในปี 2026: แพลตฟอร์มค้นหาสัญญา อัตราค่าจ้างรายวันในแต่ละประเทศ และวิธีเตรียมตัวสำหรับสัมภาษณ์เทคนิค

งาน Java Spring Boot Developer 2026: แหล่งหางาน ช่วงเงินเดือน การเตรียมตัวสัมภาษณ์

งาน Java Spring Boot Developer 2026: แหล่งหางาน ช่วงเงินเดือน การเตรียมตัวสัมภาษณ์

คู่มือฉบับสมบูรณ์สำหรับงาน Java Spring Boot developer ปี 2026: แพลตฟอร์มหางาน ข้อมูลเงินเดือนล่าสุด และกลยุทธ์การเตรียมตัวสัมภาษณ์สำหรับตำแหน่ง backend ระดับ enterprise