Spring Boot DevTools for Hot Reloading in Java

Spring Boot DevTools is a set of development-time tools that dramatically improves the development experience by providing automatic restart, live reload, and property defaults. This article explores how to use DevTools for efficient hot reloading in Java applications.

Setup and Configuration

1. Adding DevTools to Your Project

Maven:

<dependencies>
<!-- Other dependencies -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
</dependencies>

Gradle:

dependencies {
// Other dependencies
developmentOnly 'org.springframework.boot:spring-boot-devtools'
}

2. Basic Configuration

application.properties:

# DevTools specific properties
spring.devtools.restart.enabled=true
spring.devtools.restart.log-condition-evaluation-delta=false
spring.devtools.livereload.enabled=true
spring.devtools.livereload.port=35729
# Exclude specific paths from restart
spring.devtools.restart.exclude=static/**,public/**,templates/**
# Additional restart trigger paths
spring.devtools.restart.additional-paths=src/main/java

application.yml:

spring:
devtools:
restart:
enabled: true
log-condition-evaluation-delta: false
exclude: "static/**,public/**,templates/**"
additional-paths: "src/main/java"
livereload:
enabled: true
port: 35729

Automatic Restart Functionality

3. How Automatic Restart Works

Spring Boot DevTools monitors classpath changes and automatically restarts the application. The restart uses two classloaders:

Base ClassLoader: For third-party jars (don't change frequently)
Restart ClassLoader: For your application code (changes frequently)

@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

4. Customizing Restart Behavior

Custom Restart Configuration:

@Component
public class CustomRestartListener implements RestartListener {
@Override
public void beforeRestart() {
System.out.println("Application is about to restart...");
// Clean up resources or save state
}
@Override
public void afterRestart() {
System.out.println("Application has restarted successfully!");
// Reinitialize components if needed
}
}

Excluding Specific Files:

@Configuration
public class DevToolsConfig {
@Bean
public DevToolsRestartCustomizer devToolsRestartCustomizer() {
return new DevToolsRestartCustomizer() {
@Override
public void customize(RestartInitializer initializer) {
// Exclude configuration files from triggering restart
initializer.exclude("config/**");
initializer.exclude("logs/**");
}
};
}
}

LiveReload Integration

5. Browser Live Reload

DevTools includes a LiveReload server that automatically refreshes the browser when static resources change.

HTML with LiveReload:

<!DOCTYPE html>
<html>
<head>
<title>My Application</title>
<!-- LiveReload script for development -->
<script>
if (window.location.hostname === 'localhost') {
document.write('<script src="http://' + (location.host || 'localhost').split(':')[0] +
':35729/livereload.js?snipver=1"></' + 'script>')
}
</script>
</head>
<body>
<h1>Welcome to My Application</h1>
<div id="content">
<!-- Dynamic content -->
</div>
</body>
</html>

6. Custom LiveReload Configuration

@Configuration
public class LiveReloadConfig {
@Autowired
private LiveReloadServer liveReloadServer;
@Bean
public LiveReloadServer liveReloadServer() {
return new LiveReloadServer(35729);
}
@EventListener
public void onClassPathChanged(ClassPathChangedEvent event) {
// Trigger LiveReload when classpath changes
liveReloadServer.triggerReload();
}
}

Global Settings

7. Global DevTools Configuration

Create .spring-boot-devtools.properties in your $HOME directory:

~/.spring-boot-devtools.properties:

# Global restart excludes
spring.devtools.restart.exclude=log4j2.xml,logback-spring.xml
# Global trigger file
spring.devtools.restart.trigger-file=.reloadtrigger
# Remote debug configuration
spring.devtools.remote.debug.enabled=true
spring.devtools.remote.debug.local-port=8000

Property Defaults

8. Development-Specific Properties

DevTools automatically sets sensible development-time defaults:

@Configuration
public class DevelopmentConfig {
@Value("${spring.h2.console.enabled:false}")
private boolean h2ConsoleEnabled;
@Value("${spring.thymeleaf.cache:false}")
private boolean thymeleafCache;
@Value("${spring.web.resources.cache.period:0}")
private int resourcesCachePeriod;
@PostConstruct
public void init() {
System.out.println("Development configuration loaded:");
System.out.println("H2 Console: " + h2ConsoleEnabled);
System.out.println("Thymeleaf Cache: " + thymeleafCache);
System.out.println("Resources Cache: " + resourcesCachePeriod);
}
}

Remote Development

9. Remote Applications with DevTools

Client Application (Development Machine):

@SpringBootApplication
public class RemoteClientApplication {
public static void main(String[] args) {
SpringApplication.run(RemoteClientApplication.class, args);
}
}

Remote Application Configuration:

# Enable remote support
spring.devtools.remote.secret=mysecret
# Remote URL
spring.devtools.remote.url=http://my-remote-server:8080

10. Remote Restart Endpoint

@RestController
public class DevelopmentController {
private final DevToolsRestartHandler restartHandler;
public DevelopmentController(DevToolsRestartHandler restartHandler) {
this.restartHandler = restartHandler;
}
@PostMapping("/dev/restart")
public ResponseEntity<String> triggerRestart() {
restartHandler.restart();
return ResponseEntity.ok("Application restart triggered");
}
@GetMapping("/dev/info")
public Map<String, Object> getDevInfo() {
Map<String, Object> info = new HashMap<>();
info.put("uptime", ManagementFactory.getRuntimeMXBean().getUptime());
info.put("restarts", getRestartCount());
return info;
}
private long getRestartCount() {
// Custom logic to track restarts
return 0L;
}
}

Integration with IDEs

11. IntelliJ IDEA Configuration

Enable automatic build:

Go to Settings → Build, Execution, Deployment → Compiler
Check Build project automatically

Registry setting:

Press Ctrl+Shift+A, type "Registry"
Find and enable compiler.automake.allow.when.app.running

12. Eclipse Configuration

Enable automatic build:

Project → Build Automatically

.spring-boot-devtools.properties in project:

spring.devtools.restart.poll-interval=1000
spring.devtools.restart.quiet-period=400

Custom Development Tools

13. Creating Custom DevTools

@Component
public class DevelopmentWatcher {
private static final Logger logger = LoggerFactory.getLogger(DevelopmentWatcher.class);
private final ApplicationEventPublisher eventPublisher;
private final FileWatcher fileWatcher;
public DevelopmentWatcher(ApplicationEventPublisher eventPublisher) {
this.eventPublisher = eventPublisher;
this.fileWatcher = new FileWatcher();
}
@PostConstruct
public void startWatching() {
fileWatcher.watchDirectory("src/main/resources/templates", this::onTemplateChange);
fileWatcher.watchDirectory("src/main/resources/static", this::onStaticResourceChange);
}
private void onTemplateChange(Path changedFile) {
logger.info("Template changed: {}", changedFile);
eventPublisher.publishEvent(new TemplateChangeEvent(this, changedFile));
}
private void onStaticResourceChange(Path changedFile) {
logger.info("Static resource changed: {}", changedFile);
eventPublisher.publishEvent(new StaticResourceChangeEvent(this, changedFile));
}
}
@Component
public class DevelopmentEventListener {
@EventListener
public void handleTemplateChange(TemplateChangeEvent event) {
// Clear template cache
// Recompile templates if needed
System.out.println("Template changed: " + event.getChangedFile());
}
@EventListener
public void handleStaticResourceChange(StaticResourceChangeEvent event) {
// Trigger browser refresh
System.out.println("Static resource changed: " + event.getChangedFile());
}
}

14. Database Development Tools

@Component
public class DatabaseDevelopmentTools {
@Autowired
private DataSource dataSource;
@Value("${spring.datasource.url:}")
private String datasourceUrl;
@EventListener
public void onApplicationReady(ApplicationReadyEvent event) {
if (isDevelopmentProfile() && isH2Database()) {
initializeDevelopmentData();
}
}
private boolean isDevelopmentProfile() {
return Arrays.stream(environment.getActiveProfiles())
.anyMatch(profile -> profile.equals("dev") || profile.equals("development"));
}
private boolean isH2Database() {
return datasourceUrl.contains("h2");
}
private void initializeDevelopmentData() {
try (Connection conn = dataSource.getConnection();
Statement stmt = conn.createStatement()) {
// Insert development test data
stmt.execute("INSERT INTO users (username, email) VALUES ('devuser', '[email protected]')");
logger.info("Development data initialized");
} catch (SQLException e) {
logger.warn("Failed to initialize development data", e);
}
}
}

Performance Optimization

15. Optimizing Restart Performance

@Configuration
public class PerformanceConfig {
@Bean
@Profile("dev")
public RestartClassLoader restartClassLoader() {
return new RestartClassLoader() {
@Override
protected boolean isExcludedFromRestart(String className) {
// Exclude large libraries to improve restart performance
return className.startsWith("org.hibernate.") ||
className.startsWith("com.fasterxml.jackson.") ||
className.startsWith("org.springframework.security.");
}
};
}
}

application-dev.properties:

# Optimize for faster restarts
spring.devtools.restart.poll-interval=1000
spring.devtools.restart.quiet-period=500
# Exclude large libraries
spring.devtools.restart.exclude=
org.hibernate./*,
com.fasterxml.jackson./*,
org.springframework.security./*

Testing with DevTools

16. Test Configuration

@SpringBootTest
@TestPropertySource(properties = {
"spring.devtools.restart.enabled=false",
"spring.devtools.livereload.enabled=false"
})
public class ApplicationTests {
@Test
public void contextLoads() {
// Test that application starts correctly
}
@Test
@DirtiesContext
public void testWithRestart() {
// Test that survives application restart
}
}
@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
public class RepositoryTests {
@Autowired
private TestEntityManager entityManager;
@Autowired
private UserRepository userRepository;
@Test
public void testRepositoryOperations() {
// Repository tests work with DevTools
User user = new User("testuser", "[email protected]");
entityManager.persist(user);
User found = userRepository.findByUsername("testuser");
assertThat(found).isNotNull();
}
}

Troubleshooting Common Issues

17. Common Problems and Solutions

@Component
public class DevToolsDiagnostics {
private static final Logger logger = LoggerFactory.getLogger(DevToolsDiagnostics.class);
@EventListener
public void onApplicationEvent(ApplicationEvent event) {
if (event instanceof RestartEvent) {
logger.info("Restart event detected");
logClasspathInfo();
}
}
private void logClasspathInfo() {
try {
ClassLoader classLoader = getClass().getClassLoader();
if (classLoader instanceof URLClassLoader) {
URL[] urls = ((URLClassLoader) classLoader).getURLs();
logger.info("Classpath URLs: {}", Arrays.toString(urls));
}
} catch (Exception e) {
logger.warn("Failed to log classpath info", e);
}
}
}

Common Configuration Fixes:

# If restarts are too slow
spring.devtools.restart.quiet-period=500ms
spring.devtools.restart.poll-interval=1s
# If LiveReload isn't working
spring.devtools.livereload.port=35729
spring.devtools.livereload.enabled=true
# If specific files aren't triggering restart
spring.devtools.restart.additional-paths=src/main/java,src/main/resources
spring.devtools.restart.trigger-file=.reloadtrigger

Best Practices

18. Development Workflow Optimization

@Profile("dev")
@Component
public class DevelopmentAssistant {
@Autowired
private Environment environment;
@PostConstruct
public void printDevelopmentInfo() {
System.out.println("=== Development Mode Active ===");
System.out.println("Active Profiles: " + Arrays.toString(environment.getActiveProfiles()));
System.out.println("DevTools: Enabled");
System.out.println("LiveReload: Port 35729");
System.out.println("Automatic Restart: Active");
System.out.println("===============================");
}
@EventListener
public void onRestart(RestartEvent event) {
System.out.println("Application restarted at: " + new Date());
System.out.println("Restart cause: " + event.getSource());
}
}

Conclusion

Spring Boot DevTools significantly enhances developer productivity by providing:

Fast application restarts without full JVM shutdown
Live browser reloading for static content changes
Sensible development defaults for caching and debugging
Remote development support for cloud environments
Customizable restart triggers and exclusions

By properly configuring and utilizing DevTools, you can achieve sub-second restart times and a seamless development experience that closely mirrors production behavior while maintaining development convenience.