Spring Boot DevTools en 2026: hot reload, LiveReload y productividad para desarrolladores

Guía completa de Spring Boot DevTools en 2026: instalación con Maven y Gradle, cómo funciona el reinicio automático, propiedades spring.devtools, LiveReload obsoleto, @RestartScope con Testcontainers y preguntas de entrevista.

Spring Boot DevTools reiniciando una aplicación Java con hot reload

Cada cambio en una aplicación Spring Boot sin herramientas de apoyo implica el mismo ritual: detener el servidor, recompilar, volver a arrancar y esperar. Spring Boot DevTools reduce ese ciclo a uno o dos segundos reiniciando solo el código del proyecto, sin tocar la JVM ni las librerías externas. En 2026, con Spring Boot 4.1 como línea estable (4.1.2 al momento de escribir este artículo), el reinicio automático sigue siendo la pieza central del módulo, mientras que LiveReload quedó marcado como obsoleto.

Spring Boot DevTools en pocas líneas

DevTools divide el classpath entre dos classloaders: uno base para los jars de terceros y uno de reinicio para las clases del proyecto. Cuando cambia una clase compilada, solo se descarta y se vuelve a crear el segundo, por lo que el reinicio resulta mucho más rápido que un arranque en frío. Además, DevTools desactiva la caché de plantillas y se apaga por sí solo cuando la aplicación se ejecuta empaquetada con java -jar.

Cómo agregar spring-boot-devtools al proyecto

DevTools es un único artefacto. Lo que realmente importa es el alcance de la dependencia: nunca debe propagarse a otros módulos ni terminar dentro del archivo que se despliega en producción. Maven lo resuelve con optional y Gradle con la configuración developmentOnly que aporta el plugin de 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>

En Gradle basta con una línea:

build.gradle.ktskotlin
dependencies {
    // developmentOnly: on the classpath for bootRun, absent from bootJar
    developmentOnly("org.springframework.boot:spring-boot-devtools")
}

Tanto el plugin de Maven como el de Gradle excluyen DevTools del jar reempaquetado de forma predeterminada. Como segunda barrera, DevTools detecta un arranque "totalmente empaquetado" (java -jar o un classloader de lanzador personalizado) y se desactiva, ya que la referencia oficial de DevTools considera ese tipo de arranque como producción. Es posible forzarlo con -Dspring.devtools.restart.enabled=true, y eso es exactamente lo que un despliegue productivo debe evitar.

Qué hace realmente el hot reload de Spring Boot

Hablar de "hot reload en Spring Boot" es algo impreciso. DevTools no reemplaza bytecode dentro de una JVM en ejecución: lo que hace es un reinicio, aunque uno muy barato. La siguiente tabla compara las alternativas disponibles.

MecanismoQué cambia sin reiniciarCosto por cambioHerramientas
HotSwap de la JVM (depurador)Solo cuerpos de métodosPrácticamente nuloDepurador de cualquier IDE
Reinicio de DevToolsCualquier clase, bean o configuraciónNormalmente de 1 a 3 segundosspring-boot-devtools
Reinicio completoTodoTiempo de arranque completoNinguna
Agentes de recargaLa mayoría de cambios estructuralesPrácticamente nuloJRebel y similares

La velocidad proviene del diseño con dos classloaders. Los jars descargados de Maven Central casi nunca cambian durante una sesión de trabajo, así que permanecen cargados en el classloader base, junto con toda la optimización JIT ya realizada. Las clases del proyecto, ubicadas en target/classes o build/classes, viven en el classloader de reinicio. Un cambio descarta ese classloader, se crea uno nuevo y el ApplicationContext se reconstruye desde cero.

De ahí se derivan dos consecuencias prácticas:

  • El estado en memoria se pierde. Cachés locales, sesiones guardadas en memoria y el avance de tareas programadas desaparecen con cada reinicio. Es intencional: el contexto se reconstruye por completo.
  • El reinicio lo dispara el classpath, no el editor. DevTools vigila la salida de compilación. Guardar un archivo .java no tiene efecto hasta que el IDE o la herramienta de build lo compila.

Este segundo punto explica la mayoría de los reportes de "DevTools no funciona". En IntelliJ IDEA hay que compilar el proyecto (Ctrl+F9 / Cmd+F9) o activar "Build project automatically" junto con la opción avanzada que permite el auto-make mientras la aplicación está corriendo. La documentación de Spring Boot en IntelliJ IDEA describe las opciones de la configuración de ejecución ("On update action", "On frame deactivation") que disparan esa compilación. Eclipse y Spring Tools compilan al guardar, de modo que el reinicio ocurre sin configuración adicional.

Ajustar el reinicio automático con las propiedades spring.devtools

DevTools se configura mediante las propiedades spring.devtools.*. Conviene conocer los valores por defecto de Spring Boot 4.1.2, porque explican varios comportamientos inesperados: el observador de archivos revisa el disco cada 1 segundo y espera un período de calma de 400 ms antes de reiniciar. Gracias a eso, una compilación que modifica cinco archivos genera un solo reinicio y no cinco.

La siguiente configuración adapta DevTools a un proyecto que compila con lentitud (build multimódulo grande, unidad de red, volumen de Docker) y que sirve recursos estáticos desde una carpeta generada por el 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

Algunas reglas rigen estas propiedades:

  • spring.devtools.restart.exclude reemplaza la lista predeterminada (META-INF/maven/**, META-INF/resources/**, resources/**, static/**, public/**, templates/**, clases de prueba y archivos de información del build). additional-exclude agrega elementos a esa lista, que es casi siempre lo que se busca.
  • Los recursos excluidos no provocan reinicios, pero se sirven actualizados igualmente, porque DevTools desactiva cachés como spring.thymeleaf.cache y fija spring.web.resources.cache.period en 0.
  • El archivo disparador debe estar en el classpath (src/main/resources/.reloadtrigger). IntelliJ IDEA Ultimate y Spring Tools saben actualizarlo después de cada build.
  • spring.devtools.restart.enabled=false en application.properties detiene la vigilancia de archivos, pero el classloader de reinicio se inicializa de todos modos. Para desactivar DevTools por completo, la propiedad de sistema debe establecerse en main, antes de llamar a SpringApplication.run.

Para configuraciones que aplican a todos los proyectos de una máquina, DevTools lee un archivo global en $HOME/.config/spring-boot/, llamado spring-boot-devtools.properties (o .yaml / .yml). Es el lugar adecuado para una preferencia personal, como el archivo disparador, que no debería subirse al repositorio del equipo. Ese archivo no admite perfiles.

¿Listo para aprobar tus entrevistas de Spring Boot?

Practica con nuestros simuladores interactivos, flashcards y tests técnicos.

LiveReload en Spring Boot: obsoleto desde la 4.1

LiveReload refresca el navegador automáticamente cuando cambia un recurso. DevTools incluye un servidor compatible con LiveReload en el puerto 35729, al que se conecta una extensión del navegador. En Spring Boot 4.1 ese servidor viene apagado por defecto y debe habilitarse de forma explícita:

properties
# application-dev.properties
# Deprecated since Spring Boot 4.1.0, no replacement planned
spring.devtools.livereload.enabled=true
spring.devtools.livereload.port=35729

Las notas de la versión 4.1 de Spring Boot lo dicen sin rodeos: debido a la caída en su popularidad y soporte, la función LiveReload de DevTools queda obsoleta y no tendrá reemplazo. Las extensiones de navegador apenas reciben mantenimiento, y la mayoría de los frontends de 2026 se construyen con Vite u otro servidor de desarrollo que ya ofrece reemplazo de módulos en caliente (HMR).

No conviene apostar por LiveReload en un flujo nuevo

Los proyectos con Thymeleaf que ya lo usan pueden mantener spring.devtools.livereload.enabled=true por ahora, pero una propiedad obsoleta en Spring Boot es candidata a desaparecer en una versión mayor posterior. Para plantillas renderizadas en el servidor, la desactivación de cachés que aplica DevTools ya permite ver la última versión de la plantilla con un simple refresco manual del navegador, sin reiniciar la aplicación.

Trampas del classloader de reinicio y la ClassCastException

El error de DevTools más común parece un sinsentido: com.example.Order cannot be cast to com.example.Order. Ambos nombres coinciden porque las dos clases provienen de classloaders distintos. Un Order lo cargó el classloader de reinicio y el otro el classloader base (o un classloader de reinicio anterior que ya debería haberse descartado).

Suele aparecer en tres escenarios:

  1. Una librería deserializa objetos con un ObjectInputStream estándar, que resuelve las clases con el classloader equivocado. La replicación de sesiones y algunas cachés funcionan así.
  2. Un módulo del propio proyecto se consume como jar (una librería common en un build multimódulo) y termina en el classloader base, mientras que las clases que lo referencian están en el de reinicio.
  3. Un campo estático conserva una instancia creada antes del último reinicio.

Para el segundo caso, DevTools lee un archivo META-INF/spring-devtools.properties del classpath. Sus claves mueven jars entre ambos classloaders mediante expresiones regulares:

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

Las claves solo necesitan ser únicas: lo que cuenta es el prefijo restart.include. o restart.exclude.. Para el primer caso, la solución es deserializar con el ConfigurableObjectInputStream de Spring, pasándole Thread.currentThread().getContextClassLoader(), que apunta al classloader de reinicio vigente.

Si los reinicios siguen siendo demasiado lentos o los conflictos de classloaders no tienen arreglo, la alternativa documentada es un agente de recarga como JRebel, que redefine las clases en el lugar en lugar de reconstruir el contexto.

DevTools con Testcontainers y @RestartScope

Desde Spring Boot 3.1, un proyecto puede levantar sus bases de datos y brokers con Testcontainers durante el desarrollo, mediante una clase lanzadora ubicada en src/test/java. Combinado con reinicios ingenuos, el resultado es incómodo: cada reinicio destruiría y volvería a crear el contenedor de PostgreSQL, lo que cuesta varios segundos y borra los datos.

@RestartScope, incluido en el módulo DevTools, resuelve justamente eso: un bean anotado con él sobrevive a los reinicios de DevTools. La configuración siguiente sigue la guía de servicios en tiempo de desarrollo de Spring Boot, con los nombres de paquete de Testcontainers 2 que utiliza 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");
    }
}

La clase lanzadora reutiliza el método main real y le añade esa configuración:

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

La aplicación arranca con ./mvnw spring-boot:test-run o ./gradlew bootTestRun. Hay un detalle de Gradle que rompe este esquema sin dar aviso: con developmentOnly, DevTools no está en el classpath de bootTestRun, así que los cambios de código se ignoran. La dependencia debe pasar a testAndDevelopmentOnly("org.springframework.boot:spring-boot-devtools"). La parte de pruebas de integración de este enfoque se aborda en la guía de Testcontainers con Spring Boot.

DevTools remoto y por qué producción queda fuera

DevTools también puede enviar cambios a una aplicación que corre en otro lugar, por ejemplo en un contenedor dentro de un servidor de desarrollo compartido. La parte servidora solo se activa cuando se define spring.devtools.remote.secret y cuando DevTools se incluye explícitamente en el archivo empaquetado (excludeDevtools=false en el plugin de Maven). El cliente es org.springframework.boot.devtools.RemoteSpringApplication, que se ejecuta desde el IDE con la URL remota como argumento.

La documentación marca los límites con claridad: DevTools remoto solo debe usarse en una red de confianza o sobre HTTPS, nunca en producción, y no es compatible con aplicaciones Spring WebFlux. Un endpoint que recibe archivos de clases y reinicia la aplicación es, por definición, un canal de ejecución remota de código. En la mayoría de los entornos de 2026, ejecutar la aplicación de forma local contra servicios de Testcontainers o Docker Compose ofrece un ciclo más rápido sin ninguna de esas exposiciones.

Preguntas de entrevista sobre Spring Boot DevTools

En las entrevistas de Spring Boot, DevTools suele funcionar como puerta de entrada a un tema más profundo: la carga de clases y el ciclo de vida del contexto de aplicación. Estas son las preguntas más frecuentes y la respuesta que se espera de un perfil con experiencia:

  • "¿DevTools hace hot swap o reinicia?" Reinicia. Descarta el classloader de reinicio y reconstruye el ApplicationContext; la JVM y el classloader base siguen vivos. Responder "hot swap" es el error típico de un perfil junior.
  • "¿Por qué es seguro dejar DevTools en el pom?" Por tres capas: el alcance optional o developmentOnly, la exclusión del jar reempaquetado y la desactivación automática con java -jar. Una respuesta sólida menciona que forzar spring.devtools.restart.enabled=true anula la tercera capa.
  • "¿De dónde sale el error X cannot be cast to X?" De dos classloaders que cargan la misma clase; se corrige con META-INF/spring-devtools.properties o con el classloader de contexto.
  • "¿Qué ocurre con una caché en memoria al reiniciar?" Se pierde, salvo que el bean esté en @RestartScope.

Estas preguntas se cruzan con temas de configuración, por lo que el módulo de preguntas de entrevista sobre Spring Boot DevTools se complementa bien con el módulo de perfiles y entorno, ya que un perfil dev es donde suele vivir la mayoría de las propiedades vistas aquí. El banco completo de preguntas está en la página de la tecnología Spring Boot.

Lista de verificación de Spring Boot DevTools para 2026

  • Declarar spring-boot-devtools como optional (Maven) o developmentOnly (Gradle), y cambiar a testAndDevelopmentOnly cuando se use un lanzador de Testcontainers con bootTestRun.
  • Confirmar que el IDE compila al guardar o al perder el foco: DevTools vigila clases compiladas, no archivos fuente.
  • Usar spring.devtools.restart.additional-exclude en lugar de exclude, para conservar las exclusiones predeterminadas de recursos estáticos y plantillas.
  • Definir un archivo disparador en el archivo global ~/.config/spring-boot/spring-boot-devtools.properties cuando los reinicios constantes estorban durante un refactor.
  • Tratar LiveReload como obsoleto desde Spring Boot 4.1.0 y apoyarse en el servidor de desarrollo del frontend o en un refresco manual.
  • Anotar los contenedores de desarrollo con @RestartScope para que PostgreSQL o Kafka sobrevivan a cada reinicio.
  • Diagnosticar X cannot be cast to X como una separación de classloaders y resolverlo con entradas restart.include.

Conclusión

Spring Boot DevTools sigue siendo en 2026 la forma más directa de acortar el ciclo de desarrollo de una aplicación Java. Una dependencia con el alcance correcto, un IDE que compila en el momento adecuado y unas pocas propiedades spring.devtools.restart.* ajustadas al proyecto bastan para que cada iteración tome segundos. Entender el modelo de dos classloaders ayuda a esquivar las trampas habituales, a aprovechar @RestartScope con Testcontainers y a responder con precisión en una entrevista técnica. LiveReload, en cambio, ya no justifica ninguna inversión nueva.

¡Empieza a practicar!

Pon a prueba tu conocimiento con nuestros simuladores de entrevista y tests técnicos.

Reto diario

¿Sabrías detectar el bug en Spring Boot?

Un fragmento real, un bug oculto, un intento al día. Sin cuenta para probar.

Anthony Fillion-Maillet

Escrito por

Anthony Fillion-Maillet

Fundador de SharpSkill

Desarrollador fullstack desde hace más de 10 años. Dirige SharpSkill y responde por todo lo que se publica aquí.

Actualizado el 12 de noviembre de 2026

Etiquetas

#spring boot devtools
#hot reload
#livereload
#productividad
#testcontainers

Compartir

Artículos relacionados