Spring Boot DevTools em 2026: hot reload, LiveReload e produtividade do desenvolvedor
Guia completo do Spring Boot DevTools em 2026: instalação com Maven e Gradle, como funciona o reinício automático, propriedades spring.devtools, LiveReload depreciado, @RestartScope com Testcontainers e perguntas de entrevista.

Em um projeto Spring Boot sem ferramentas de apoio, cada alteração exige parar o servidor, recompilar, subir tudo de novo e esperar. O Spring Boot DevTools encurta esse ciclo para um ou dois segundos ao reiniciar apenas o código do projeto, mantendo a JVM e as bibliotecas externas carregadas. Em 2026, com o Spring Boot 4.1 como linha estável (4.1.2 no momento da escrita), o reinício automático continua sendo o principal recurso do módulo, enquanto o LiveReload passou a ser oficialmente depreciado.
O DevTools divide o classpath em dois classloaders: um classloader base para os jars de terceiros e um classloader de reinício para as classes do projeto. Quando uma classe compilada muda, apenas o segundo é descartado e recriado, o que torna o reinício muito mais rápido do que uma inicialização a frio. O DevTools também desliga o cache de templates e se desativa sozinho quando a aplicação roda empacotada com java -jar.
Adicionando a dependência spring-boot-devtools
O DevTools é um único artefato. O detalhe que importa é o escopo: a dependência nunca deve vazar para outros módulos nem acabar dentro do pacote de produção. No Maven isso se expressa com optional; no Gradle, com a configuração developmentOnly fornecida pelo plugin do Spring Boot.
<!-- 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>No Gradle, uma linha resolve:
dependencies {
// developmentOnly: on the classpath for bootRun, absent from bootJar
developmentOnly("org.springframework.boot:spring-boot-devtools")
}Os plugins do Maven e do Gradle removem o DevTools do jar reempacotado por padrão. Como segunda proteção, o DevTools detecta uma execução "totalmente empacotada" (java -jar ou um classloader de inicializador customizado) e se desativa, já que a referência oficial do DevTools trata esse tipo de execução como produção. É possível forçar a ativação com -Dspring.devtools.restart.enabled=true, e é justamente isso que um deploy de produção precisa evitar.
Como o hot reload do Spring Boot funciona de verdade
A expressão "hot reload do Spring Boot" engana um pouco. O DevTools não troca bytecode dentro de uma JVM em execução: ele faz um reinício, só que um reinício barato. A tabela abaixo posiciona o DevTools em relação às outras abordagens.
| Mecanismo | O que muda sem reiniciar | Custo por alteração | Ferramenta |
|---|---|---|---|
| HotSwap da JVM (depurador) | Apenas corpos de métodos | Praticamente zero | Depurador de qualquer IDE |
| Reinício do DevTools | Qualquer classe, bean ou configuração | Em geral de 1 a 3 segundos | spring-boot-devtools |
| Reinício completo | Tudo | Tempo total de inicialização | Nenhuma |
| Agentes de recarga | A maioria das mudanças estruturais | Praticamente zero | JRebel e similares |
A rapidez vem da arquitetura com dois classloaders. Os jars baixados do Maven Central quase nunca mudam durante uma sessão de desenvolvimento, então permanecem carregados no classloader base, junto com toda a otimização JIT já feita sobre eles. As classes do projeto, vindas de target/classes ou build/classes, ficam no classloader de reinício. Uma alteração descarta esse classloader, um novo é criado e o ApplicationContext é reconstruído do zero.
Duas consequências aparecem no dia a dia:
- O estado em memória se perde. Caches locais, sessões guardadas em memória e o progresso de tarefas agendadas somem a cada reinício. Isso é intencional: o contexto é reconstruído.
- Quem dispara o reinício é o classpath, não o editor. O DevTools observa a saída da compilação. Salvar um arquivo
.javanão tem efeito até que a IDE ou a ferramenta de build o compile.
Esse segundo ponto explica a maior parte das reclamações do tipo "o DevTools não funciona". No IntelliJ IDEA, é preciso compilar o projeto (Ctrl+F9 / Cmd+F9) ou ativar "Build project automatically" junto com a configuração avançada que permite o auto-make enquanto a aplicação está rodando. A documentação de Spring Boot do IntelliJ IDEA descreve as opções da configuração de execução ("On update action", "On frame deactivation") que disparam essa compilação. Eclipse e Spring Tools compilam ao salvar, então o reinício acontece sem nenhuma configuração extra.
Ajustando o reinício automático com as propriedades spring.devtools
O DevTools é configurado pelas propriedades spring.devtools.*. Vale conhecer os valores padrão do Spring Boot 4.1.2, porque eles explicam alguns comportamentos curiosos: o observador de arquivos verifica o disco a cada 1 segundo e aguarda um período de silêncio de 400 ms antes de reiniciar. Assim, uma compilação que altera cinco arquivos gera um único reinício, e não cinco.
A configuração abaixo adapta o DevTools a um projeto que compila devagar (build multimódulo grande, unidade de rede, volume Docker) e que serve arquivos estáticos a partir de uma pasta gerada pelo frontend.
# 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=falseAlgumas regras governam essas propriedades:
spring.devtools.restart.excludesubstitui a lista padrão (META-INF/maven/**,META-INF/resources/**,resources/**,static/**,public/**,templates/**, classes de teste e arquivos de informação do build). Jáadditional-excludeacrescenta itens a essa lista, o que quase sempre é a intenção.- Recursos excluídos não disparam reinício, mas continuam sendo servidos atualizados, porque o DevTools desliga caches como
spring.thymeleaf.cachee definespring.web.resources.cache.periodcomo 0. - O arquivo de gatilho precisa estar no classpath (
src/main/resources/.reloadtrigger). O IntelliJ IDEA Ultimate e o Spring Tools sabem atualizá-lo após cada build. spring.devtools.restart.enabled=falsenoapplication.propertiesinterrompe a observação de arquivos, mas o classloader de reinício ainda é inicializado. Para desativar o DevTools por completo, a propriedade de sistema deve ser definida nomain, antes da chamada aSpringApplication.run.
Para configurações válidas em todos os projetos de uma máquina, o DevTools lê um arquivo global em $HOME/.config/spring-boot/, chamado spring-boot-devtools.properties (ou .yaml / .yml). É o lugar certo para uma preferência pessoal, como o arquivo de gatilho, que não deveria ir para o repositório do time. Esse arquivo não suporta profiles.
Pronto para mandar bem nas entrevistas de Spring Boot?
Pratique com nossos simuladores interativos, flashcards e testes tecnicos.
LiveReload no Spring Boot: depreciado desde a 4.1
O LiveReload atualiza o navegador automaticamente quando um recurso muda. O DevTools embute um servidor compatível com LiveReload na porta 35729, ao qual uma extensão de navegador se conecta. No Spring Boot 4.1, esse servidor vem desligado por padrão e precisa ser habilitado explicitamente:
# application-dev.properties
# Deprecated since Spring Boot 4.1.0, no replacement planned
spring.devtools.livereload.enabled=true
spring.devtools.livereload.port=35729As notas de lançamento do Spring Boot 4.1 são diretas: por causa da queda de popularidade e de suporte, o recurso LiveReload do DevTools foi depreciado e não terá substituto. As extensões de navegador praticamente não recebem manutenção, e a maioria dos frontends em 2026 é construída com Vite ou outro servidor de desenvolvimento que já oferece substituição de módulos a quente (HMR).
Projetos Thymeleaf existentes podem manter spring.devtools.livereload.enabled=true por enquanto, mas uma propriedade depreciada no Spring Boot é candidata a remoção em uma versão major futura. Para templates renderizados no servidor, a desativação de cache aplicada pelo DevTools já garante que um simples refresh manual no navegador mostre a versão mais recente do template, sem reiniciar a aplicação.
Armadilhas do classloader de reinício e a ClassCastException
O bug mais comum do DevTools parece absurdo: com.example.Order cannot be cast to com.example.Order. Os nomes são idênticos porque as duas classes vêm de classloaders diferentes. Um Order foi carregado pelo classloader de reinício e o outro pelo classloader base (ou por um classloader de reinício anterior que já deveria ter sido descartado).
O problema costuma surgir em três situações:
- Uma biblioteca desserializa objetos com um
ObjectInputStreampadrão, que resolve as classes pelo classloader errado. Replicação de sessão e alguns caches fazem isso. - Um módulo do próprio projeto é consumido como jar (uma biblioteca
commonem um build multimódulo) e vai parar no classloader base, enquanto as classes que o referenciam estão no classloader de reinício. - Um campo estático guarda uma instância criada antes do último reinício.
Para o segundo caso, o DevTools lê um arquivo META-INF/spring-devtools.properties do classpath. Suas chaves movem jars entre os dois classloaders usando expressões regulares:
# 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.-]+\\.jarAs chaves só precisam ser únicas: o que vale é o prefixo restart.include. ou restart.exclude.. Para o primeiro caso, a correção é desserializar com o ConfigurableObjectInputStream do Spring, passando Thread.currentThread().getContextClassLoader(), que aponta para o classloader de reinício atual.
Quando os reinícios continuam lentos demais ou os conflitos de classloader não têm solução, a alternativa documentada é um agente de recarga como o JRebel, que redefine as classes no lugar em vez de reconstruir o contexto.
DevTools com Testcontainers e @RestartScope
Desde o Spring Boot 3.1, um projeto pode subir seus bancos de dados e brokers com Testcontainers em tempo de desenvolvimento, usando uma classe de inicialização em src/test/java. Combinado a reinícios ingênuos, o resultado incomoda: cada reinício destruiria e recriaria o contêiner do PostgreSQL, o que custa vários segundos e apaga os dados.
O @RestartScope, que faz parte do módulo DevTools, resolve exatamente isso: um bean anotado com ele sobrevive aos reinícios do DevTools. A configuração a seguir segue o guia de serviços em tempo de desenvolvimento do Spring Boot, com os nomes de pacote do Testcontainers 2 usados pelo Spring Boot 4.
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");
}
}A classe de inicialização reaproveita o main real e acrescenta essa configuração:
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);
}
}A aplicação sobe com ./mvnw spring-boot:test-run ou ./gradlew bootTestRun. Um detalhe do Gradle quebra esse arranjo silenciosamente: com developmentOnly, o DevTools não fica no classpath do bootTestRun, então as alterações de código são ignoradas. A dependência precisa mudar para testAndDevelopmentOnly("org.springframework.boot:spring-boot-devtools"). O lado de testes de integração dessa abordagem é tratado no guia de Testcontainers com Spring Boot.
DevTools remoto e por que a produção fica de fora
O DevTools também consegue enviar alterações para uma aplicação rodando em outro lugar, por exemplo em um contêiner dentro de um servidor de desenvolvimento compartilhado. O lado servidor só é ativado quando spring.devtools.remote.secret está definido e quando o DevTools é incluído explicitamente no pacote (excludeDevtools=false no plugin do Maven). O cliente é org.springframework.boot.devtools.RemoteSpringApplication, executado pela IDE com a URL remota como argumento.
A documentação deixa os limites bem claros: o DevTools remoto só deve rodar em rede confiável ou sobre HTTPS, nunca em produção, e não suporta aplicações Spring WebFlux. Um endpoint que aceita arquivos de classe e reinicia a aplicação é, por construção, um canal de execução remota de código. Na maioria dos ambientes de 2026, rodar a aplicação localmente com serviços do Testcontainers ou do Docker Compose entrega um ciclo mais rápido, sem nenhuma dessas exposições.
Perguntas de entrevista sobre Spring Boot DevTools
Em entrevistas de Spring Boot, o DevTools costuma servir de porta de entrada para um assunto mais profundo: carregamento de classes e ciclo de vida do contexto da aplicação. Estas são as perguntas mais comuns, com a resposta esperada de um desenvolvedor pleno ou sênior:
- "O DevTools faz hot swap ou reinício?" Reinício. Ele descarta o classloader de reinício e reconstrói o
ApplicationContext; a JVM e o classloader base continuam vivos. Responder "hot swap" é o erro clássico de quem está começando. - "Por que é seguro deixar o DevTools no pom?" Por três camadas: o escopo
optionaloudevelopmentOnly, a exclusão do jar reempacotado e a desativação automática comjava -jar. Uma resposta forte menciona que forçarspring.devtools.restart.enabled=trueanula a terceira camada. - "De onde vem o erro
X cannot be cast to X?" De dois classloaders carregando a mesma classe; a correção passa porMETA-INF/spring-devtools.propertiesou pelo classloader de contexto. - "O que acontece com um cache em memória no reinício?" Ele se perde, a menos que o bean esteja em
@RestartScope.
Essas perguntas se cruzam com temas de configuração, então o módulo de perguntas de entrevista sobre Spring Boot DevTools combina bem com o módulo de profiles e ambiente, já que um profile dev é onde a maior parte das propriedades vistas aqui deve ficar. O banco completo de perguntas está na página da tecnologia Spring Boot.
Checklist do Spring Boot DevTools para 2026
- Declarar
spring-boot-devtoolscomooptional(Maven) oudevelopmentOnly(Gradle), trocando paratestAndDevelopmentOnlyao usar um inicializador do Testcontainers combootTestRun. - Garantir que a IDE compile ao salvar ou ao perder o foco: o DevTools observa classes compiladas, não arquivos-fonte.
- Usar
spring.devtools.restart.additional-excludeem vez deexclude, para manter as exclusões padrão de arquivos estáticos e templates. - Configurar um arquivo de gatilho no arquivo global
~/.config/spring-boot/spring-boot-devtools.propertiesquando reinícios constantes atrapalham durante um refactoring. - Tratar o LiveReload como depreciado desde o Spring Boot 4.1.0 e contar com o servidor de desenvolvimento do frontend ou com um refresh manual.
- Anotar os contêineres de desenvolvimento com
@RestartScopepara que PostgreSQL ou Kafka sobrevivam a cada reinício. - Diagnosticar
X cannot be cast to Xcomo uma divisão de classloaders e corrigir com entradasrestart.include.
Conclusão
Em 2026, o Spring Boot DevTools continua sendo o caminho mais simples para encurtar o ciclo de desenvolvimento de uma aplicação Java. Uma dependência com o escopo certo, uma IDE que compila no momento adequado e algumas propriedades spring.devtools.restart.* ajustadas ao projeto bastam para que cada iteração leve poucos segundos. Entender o modelo de dois classloaders ajuda a evitar as armadilhas mais comuns, a tirar proveito do @RestartScope com Testcontainers e a responder com segurança em uma entrevista técnica. O LiveReload, por outro lado, já não justifica investimento em fluxos novos.
Comece a praticar!
Teste seus conhecimentos com nossos simuladores de entrevista e testes tecnicos.
Você saberia encontrar o bug em Spring Boot?
Um trecho real, um bug escondido, uma tentativa por dia. Sem conta para testar.

Escrito por
Anthony Fillion-MailletFundador da SharpSkill
Desenvolvedor fullstack há mais de 10 anos. Dirige a SharpSkill e responde por tudo o que é publicado aqui.
Atualizado em 12 de novembro de 2026
Tags
Compartilhar
Artigos relacionados

Testcontainers Spring Boot: testes de integração sem dor
Guia completo para configurar Testcontainers com Spring Boot 3.4. PostgreSQL, Redis e Kafka em contêineres Docker para testes de integração confiáveis e reproduzíveis.

Vagas freelance de desenvolvedor Java Spring Boot em 2026: onde encontrar contratos, valores diários e preparação
Guia completo sobre vagas freelance de Java Spring Boot em 2026: plataformas para encontrar contratos, valores diários na Europa, habilidades exigidas e preparação para entrevistas técnicas.

Vagas de desenvolvedor Java Spring Boot em 2026: onde procurar, faixas salariais e como se preparar
Mercado de trabalho Java Spring Boot em 2026: plataformas de emprego, faixas salariais na Europa e Brasil, preparação para entrevistas técnicas.