How can I write a Java application that can update itself at runtime?

I would like to implement a java application (server application) that can download a new version (.jar file) from a given url, and then update itself at runtime.

What is the best way to do this and is it possible?

I guess that the application can download a new .jar file and start it. But how should I do the handover, e.g. know when the new application is started and then exit. Or is there a better way to do this?

Solution 1:

The basic structure of a solution is as follows:

• There is a main loop responsible for repeatedly loading the latest version of the app (if required) and launching it.

• The application does its thing, but periodically checks the download URL. If it detects a new version it exits back to the launcher.

There are a number of ways you could implement this. For example:

• The launcher could be a wrapper script or binary application that starts a new JVM to run the application from a JAR file that gets replaced.

• The launcher could be a Java application that creates a classloader for the new JAR, loads an entrypoint class and calls some method on it. If you do it this way, you have to watch for classloader storage leaks, but that's not difficult. (You just need to make sure that no objects with classes loaded from the JAR are reachable after you relaunch.)

The advantages of the external wrapper approach are:

• you only need one JAR,
• you can replace the entire Java app,
• any secondary threads created by the app, etc will go away without special shutdown logic, and
• you can also deal with recovery from application crashes, etc.

The second approach requires two JARs, but has the following advantages:

• the solution is pure Java and portable,
• the changeover will be quicker, and
• you can more easily retain state across the restart (modulo leakage issues).

The "best" way depends on your specific requirements.

It should also be noted that:

• There are security risks with auto-updating. In general, if the server that provides the updates is compromised, or if the mechanisms for providing the updates are susceptible to attack, then auto-updating can lead to a compromise of the client(s).

• Pushing a update to a client that cause damage to the client could have legal risks, and risks to your business' reputation.

If you can find a way to avoid reinventing the wheel, that would be good. See the other answers for suggestions.

Solution 2:

I am currently developing a JAVA Linux Daemon and also had the need to implement an auto-update mechanism. I wanted to limit my application to one jar file, and came up with a simple solution:

Pack the updater application in the update itself.

Application: When the application detects a newer version it does the following:

1. Download update (Zipfile)
2. Extract Application and ApplicationUpdater (all in the zipfile)
3. Run updater

ApplicationUpdater: When the updater runs it does the following:

1. Stop the Application (in my case a daemon via init.d)
2. Copy the downloaded jar file to overwrite current Application
3. Start the Application
4. Cleanup.

Hope it helps someone.

Solution 3:

I've recently created update4j which is fully compatible with Java 9's module system.

It will seamlessly start the new version without a restart.

Solution 4:

This is a known problem and I recommend against reinventing a wheel - don't write your own hack, just use what other people have already done.

Two situations you need to consider:

1. App needs to be self-updatable and keep running even during update (server app, embedded apps). Go with OSGi: Bundles or Equinox p2.

2. App is a desktop app and has an installer. There are many installers with update option. Check installers list.