# 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. - Published: 2026-11-12 - Updated: 2026-11-12 - Author: Anthony Fillion-Maillet - Tags: spring boot devtools, hot reload, livereload, produtividade, testcontainers - Reading time: 11 min --- 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 org.springframework.boot spring-boot-devtools true ``` No Gradle, uma linha resolve: ```kotlin // build.gradle.kts 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](https://docs.spring.io/spring-boot/reference/using/devtools.html) 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 `.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](https://www.jetbrains.com/help/idea/spring-boot.html) 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. ## 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](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-4.1-Release-Notes) 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](https://docs.spring.io/spring-boot/reference/features/dev-services.html), com os nomes de pacote do Testcontainers 2 usados pelo 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"); } } ``` A classe de inicialização reaproveita o `main` real e acrescenta essa configuração: ```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); } } ``` 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](https://sharpskill.dev/pt/blog/spring-boot/testcontainers-spring-boot-integration-testing). ## 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](https://sharpskill.dev/pt/technologies/spring-boot/perguntas-entrevista/spring-boot-devtools) combina bem com o [módulo de profiles e ambiente](https://sharpskill.dev/pt/technologies/spring-boot/perguntas-entrevista/profiles-environment), 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](https://sharpskill.dev/pt/technologies/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. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/pt/blog/spring-boot/spring-boot-devtools-hot-reload-livereload