×News:
XavaPro 7.7.2 released -
May 13 ·
Read more
Starting from OpenXava 7.5, you can enjoy hot code reloading while developing your application.
This means you can modify any part of the code, save it, go to the browser and see the updated application.
Everything happens instantly, without needing to build, run Maven install, restart the application,
or even reload the page in the browser.
These are the changes you can make to your application without restarting it.
Most of them take effect without even reloading the browser page:
- Java code: Add, remove, or modify fields, methods, annotations, classes (including anonymous ones),
static members, and enumeration values. Anonymous class redefinition and static member initialization
are properly handled.
- Calculated properties: You can add, remove, or modify a calculated property in an entity and it will
immediately appear in the application, both in list and detail modes.
- OpenXava annotations: If you change, add, or remove OpenXava annotations like @View, @DescriptionsList
or @Tab, you'll also see the effect immediately.
- Persistent properties: When adding, modifying, or removing a persistent property from an entity,
it will be immediately visible in the user interface, in both detail and list modes. Additionally,
if schema evolution is enabled, the corresponding column will be created in the database table.
- New entities: If you create a new class and annotate it with @Entity, it will not only be
recognized but will automatically have a new module available (in the left menu and via URL).
If schema evolution is enabled, the table will be created in the database. In this case,
you need to press the reload button in the browser to see the new module.
- Controllers: If we add or remove controllers in controllers.xml, add, modify or change actions
in a controller, etc. Everything is recognized immediately, with actions appearing (or disappearing)
as soon as we trigger an action in the user interface.
- Application: We can add, modify and remove modules in application.xml. New modules are visible
after pressing reload in the browser.
- Labels and messages: If we change labels and messages in i18n files, it also takes effect without
restarting the application. However, in this case, you need to reload the browser to see the new labels.
It's not necessary to start in debug mode for changes to be recognized, but you do need to use a JetBrains
JDK with the HotSwap agent configured and started with certain options, as explained below.
IntelliJ
IntelliJ is the recommended IDE for hot code reloading with OpenXava. To use it you need a JetBrains JDK:
JBR 17, 21 or 25. Use the Project Structure... option in IntelliJ to set one of these JDKs for
your project:
If you don't have a JetBrains JDK, you can download one directly from within IntelliJ in
Project Structure..., in the SDKs section:
You also need to install a plugin called HotSwapHelper. Go to Settings > Plugins and
search for it:
With this in place you can run your application, but not in the usual way. You must use the
run with Hotswap debug option that is now available in the IntelliJ run menu:
If everything goes well, at the start of the log output you should see a message like this:
Connected to the target VM, address: '127.0.0.1:54715', transport: 'socket'
HOTSWAP AGENT: 12:30:48.070 INFO (org.hotswap.agent.HotswapAgent) - Loading Hotswap agent {2.0.2} - unlimited runtime class redefinition.
If that's the case, you can now change the code and see the effect immediately. Note that
IntelliJ does not compile the code automatically, even if you check the option to
build the project automatically (because that option doesn't work when the application
is running). What will happen is that when you change the code, a button will appear in the
IntelliJ code editor saying 'Code changed', click it to compile and reload the code:
Sometimes the button does not appear, for example if you change an XML file or the Java code
is generated by an AI assistant. In that case, press Ctrl + F9. This will compile and reload
the changed code.
With Java 25 the application stops from time to time, with Java 21 it fails much less and
with Java 17 it does not fail. Even so, it is much more practical than restarting the application for
every change. As new maintenance versions of Java 25 are released, it is expected to become increasingly
robust.
Without IDE
Hot class reloading can also be used outside IntelliJ and without any IDE, from the terminal.
First, download a JetBrains JDK from here:
https://github.com/JetBrains/JetBrainsRuntime/releases
After installing the JetBrains JDK, inside the lib folder create a hotswap folder and copy
a file named hotswap-agent.jar (without version number) into it. This jar can be downloaded from here:
https://github.com/HotswapProjects/HotswapAgent/releases
Important: when copying it into lib/hotswap, rename it so it is called exactly hotswap-agent.jar.
Now just start the application with this JDK, passing the startup options to activate HotSwap.
For example, on Linux:
export MAVEN_OPTS="-XX:+AllowEnhancedClassRedefinition -XX:HotswapAgent=fatjar"
export JAVA_HOME=/home/javi/.jdks/jbr-25.0.2
export PATH=$JAVA_HOME/bin:$PATH
mvn exec:java
On Windows:
set MAVEN_OPTS=-XX:+AllowEnhancedClassRedefinition -XX:HotswapAgent=fatjar
set JAVA_HOME=C:\Users\youruser\.jdks\jbr-25.0.2
set PATH=%JAVA_HOME%\bin;%PATH%
mvn exec:java
If done correctly, when you run the application you should see:
Connected to the target VM, address: '127.0.0.1:54715', transport: 'socket'
HOTSWAP AGENT: 12:30:48.070 INFO (org.hotswap.agent.HotswapAgent) - Loading Hotswap agent {2.0.3} - unlimited runtime class redefinition.
For more information see: https://github.com/HotswapProjects/HotswapAgent
Other IDEs
Hot class reloading can work from any IDE, such as Eclipse, NetBeans or Visual Studio Code. You just need
to use a JetBrains JDK and copy the hotswap-agent.jar into it as described in the
Without IDE section above. In addition, you need to configure the application
startup in your IDE to use the options
-XX:+AllowEnhancedClassRedefinition -XX:HotswapAgent=fatjar.
The hot reloading mechanism is designed for optimal performance, loading just the necessary metadata
only when needed or restarting the Hibernate session only when the persistent part of an entity is
modified. Additionally, in production where you use a different JDK than in development, the reloading
mechanism is disabled.
Sometimes you are developing a library or a project that is a dependency of the current project,
and you would like to see the results instantly when you change the library code too. For this case,
you can start your application indicating a list of extra classpaths. Edit your launcher class and
write something like this:
public static void main(String[] args) throws Exception {
AppServer.run("yourapp", "../yourlib/target/classes");
}
Now when something changes in ../yourlib/target/classes it will also be reloaded automatically.
This allows you to develop your library testing it in a final application, with the same agility as
with any other application.
Indicating extra classpaths when starting the application is available since version 7.5.
XavaPro
In XavaPro 7.5, there are significant improvements regarding module availability during development. When using Hot code reloading:
- When you add a new module to a XavaPro application, either by defining it in application.xml or by creating a new JPA entity,
the module appears immediately in the menu, in the root folder.
- The new module is automatically assigned to the "user" role, if this role exists.
- Similarly, if you start the application with the JDK that includes Hotswap Agent (a JetBrains JDK),
any modules added while the application was stopped will be recognized when the application starts.
This streamlines the development process, as you no longer need to manually add new modules to the "user" role to make them available.
However, in production environments (where Hotswap Agent is not used), the behavior remains unchanged for security reasons:
new modules must be explicitly assigned to a role to be available to users.