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.

Spring Boot DevTools reiniciando uma aplicação Java com hot reload

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 Spring Boot DevTools em um parágrafo

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.

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>

No Gradle, uma linha resolve:

build.gradle.ktskotlin
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.

MecanismoO que muda sem reiniciarCusto por alteraçãoFerramenta
HotSwap da JVM (depurador)Apenas corpos de métodosPraticamente zeroDepurador de qualquer IDE
Reinício do DevToolsQualquer classe, bean ou configuraçãoEm geral de 1 a 3 segundosspring-boot-devtools
Reinício completoTudoTempo total de inicializaçãoNenhuma
Agentes de recargaA maioria das mudanças estruturaisPraticamente zeroJRebel 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 .java nã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.

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

Algumas regras governam essas propriedades:

  • spring.devtools.restart.exclude substitui 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-exclude acrescenta 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.cache e define spring.web.resources.cache.period como 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=false no application.properties interrompe 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 no main, antes da chamada a SpringApplication.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:

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

As 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).

Evite montar um fluxo novo em cima do LiveReload

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:

  1. Uma biblioteca desserializa objetos com um ObjectInputStream padrão, que resolve as classes pelo classloader errado. Replicação de sessão e alguns caches fazem isso.
  2. Um módulo do próprio projeto é consumido como jar (uma biblioteca common em um build multimódulo) e vai parar no classloader base, enquanto as classes que o referenciam estão no classloader de reinício.
  3. 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:

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

As 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.

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

A classe de inicialização reaproveita o main real e acrescenta essa configuração:

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

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 optional ou developmentOnly, a exclusão do jar reempacotado e a desativação automática com java -jar. Uma resposta forte menciona que forçar spring.devtools.restart.enabled=true anula 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 por META-INF/spring-devtools.properties ou 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-devtools como optional (Maven) ou developmentOnly (Gradle), trocando para testAndDevelopmentOnly ao usar um inicializador do Testcontainers com bootTestRun.
  • 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-exclude em vez de exclude, 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.properties quando 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 @RestartScope para que PostgreSQL ou Kafka sobrevivam a cada reinício.
  • Diagnosticar X cannot be cast to X como uma divisão de classloaders e corrigir com entradas restart.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.

Desafio do dia

Você saberia encontrar o bug em Spring Boot?

Um trecho real, um bug escondido, uma tentativa por dia. Sem conta para testar.

Anthony Fillion-Maillet

Escrito por

Anthony Fillion-Maillet

Fundador 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

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

Compartilhar

Artigos relacionados