{"id":2030,"date":"2015-11-21T10:29:20","date_gmt":"2015-11-21T15:29:20","guid":{"rendered":"http:\/\/springframework.guru\/?p=2030"},"modified":"2019-05-11T14:04:55","modified_gmt":"2019-05-11T18:04:55","slug":"spring-boot-developer-tools","status":"publish","type":"post","link":"https:\/\/springframework.guru\/spring-boot-developer-tools\/","title":{"rendered":"Spring Boot Developer Tools"},"content":{"rendered":"

In the 1.3.0 release of Spring Boot<\/a> and new module is available called Spring Boot Developer Tools. This new Spring Boot module is aimed at improving developer productivity in building Spring Web Applications.<\/p>\n

When you’re developing a web application in Java, or really any programming language,\u00a0a common workflow is to code, compile, deploy, and then test in the browser. In scripting languages, such as PHP, there is no compile \/ deploy phase. The script is evaluated by the server at run time, thus negating the need for a compile \/ deploy phase.<\/p>\n

In the world of Java web development, we don’t have this luxury. Our Java code is compiled down to Java byte code, then deployed to an application server such as Tomcat. The compile, deploy, test phase is a common step in the process of writing software. The longer it takes, the greater the impact it has on your productivity. I’ve seen this cycle take just a few seconds, to 30 minutes. Yes, 30 minutes! (It was a highly coupled legacy application from the early 90s – one of the most effing awful developer experiences I’ve ever encountered!)<\/p>\n

For a long time, the Grails<\/a> community has enjoyed the benefits of automatic class reloading. It’s such a pleasure coding a Java application, and only needing to save your file to have the code automatically reload in the Tomcat container – nearly instantly. This is one of the features that drew me to web development with Grails.<\/p>\n

This feature has been missing from web development with Spring MVC for a long time. You could use a 3rd party tool such as jRebel<\/a>, but at $475 annually for a license, it’s an expensive option for those coding outside the enterprise.<\/p>\n

In the world of web development with just Spring MVC, this new feature available in Spring Boot Developer Tools has been long overdue. Way way overdue!<\/p>\n

Reloading vs Restarting<\/h1>\n

The reloading agent from Grails is now its own project, called Spring Loaded<\/a>. This takes a slightly different, but important approach than the one used in Spring Boot Developer Tools. In reloading, the agent reloads the Java class in the JVM. This avoids the need to start the Tomcat container and Spring context. But has some drawbacks. Works great for coding changes in the class itself. But change the package, or add a new class \/ Spring bean, and you still need to restart.<\/p>\n

Spring Boot Developer Tools takes a different approach, it does a restart, not a reload. BUT – under the covers, it is using two class loaders. One for all jar classes in your project, and one for your project classes. Thus on a ‘restart’, only the project classes are reloaded. The 10’s of thousands of classes contained in jar files in your typical Java Spring project are not reloaded. By doing this, restarting Tomcat and the Spring context become VERY fast. Since the Spring context is being restarted, it addresses issues found with the approach used in Spring Loaded.<\/p>\n

Use with Build Tools<\/h2>\n

The automatic restart is triggered when changes on the classpath are detected. Thus if you build with Maven or Gradle class files in the target directory will change and an automatic build will be triggered.<\/p>\n

Use with IDEs<\/h2>\n

IntelliJ and Eclipse are the two most popular IDEs for Java development. There are some notable differences in use between the two IDEs.<\/p>\n

Eclipse is the foundation for the Spring Tool Suite<\/a> (aka STS). Development of the Spring Boot Developer Tools seems biased towards STS. Which is to be expected. Both are Pivotal products. An automatic restart in Eclipse is triggered with the save action. In Eclipse, this triggers a recompile of the change classes, which triggers the automatic restart.<\/p>\n

With IntelliJ the process is slightly different. IntelliJ does not recompile on save, but unlike Eclipse, it does perform automatic file saves for you. IntelliJ can be configured to compile on save<\/a>, but this gets disabled when an application is running. Thus in IntelliJ, you need to trigger the build manually, which will in turn fire off the automatic restart. So with the extra step, the developer experience in IntelliJ is not quite as smooth.<\/p>\n

I prefer the developer experience with Spring Loaded, where the changes made to your *.java files will trigger the automatic restart\/reload. If the Spring Boot Developer Tools had been developed the same way, the developer experience in both IDEs would be the same. Maybe the team developing the Developer Tools had a technical reason for this. Or maybe it was a choice by Pivotal to promote STS on the Eclipse platform.<\/p>\n

This is inconvenient, but I’m not changing IDEs. The last time I tried STS, it was awful. Randomly hanging, or crashing. You just get what you pay for IMHO.<\/p>\n

Live Reload<\/h1>\n

Another cool feature of the Spring Boot Developer Tools is the Live Reload integration<\/a>. Live Reload is a browser plugin, which will trigger a page reload upon changes to the source. Thus when you change web content, the page in the browser will automatically refresh. Small improvement. But it is nice not clicking refresh in the browser all the time.<\/p>\n

Live Reload is advertised to work for Firefox, Chrome, and Safari. I was unable to get the plugin working in Firefox – it may be currently broken with Firefox. I did get Live Reload working fine with Chrome. I did not try using it with Safari.<\/p>\n\r\n\t

\r\n\t
\r\n\t \t

Free Introduction to Spring Tutorial<\/h3><\/div>\r\n\t\t
Are you new to the Spring Framework? Checkout my Free Introduction to Spring Online Tutorial.<\/div>\r\n\t <\/div>\r\n\t \r\n\t \t
\r\n\t
\r\n\t\t\r\n\t\t\t\t\t\t\r\n\t\t\t\tLearn More<\/span>\r\n\t\t\t\t\t\t\r\n\t\t<\/a>\r\n\t<\/div>\r\n<\/div>\r\n\t \r\n\t<\/div>\r\n\n

Remote Development and Debug<\/h1>\n

The Spring Boot Developer Tools includes support of doing remote development and debugging. You can configure automatic restarts\u00a0and debugging to a remote server. Kind of a cool thing to do. But I’m not sure where I would personally ever use this feature. The folks from Pivotal have a little demonstration of this towards\u00a0the end of this video<\/a>.<\/p>\n

Demonstration of Spring Boot Developer Tools<\/h1>\n

I’ve described how Spring Boot Developer Tools can improve the development workflow and improve your productivity. But a seeing a demonstration is far more effective. I recorded this video to show you the Developer Tools in action.<\/p>\n

<\/div><\/div>
<\/div>
<\/div>
<\/div><\/div><\/div>