Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

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?

like image 362
Jonas Avatar asked Oct 23 '10 04:10

Jonas


People also ask

How do you update a Java program?

Go to the Windows Start Button and select Settings then Control Panel. Click Java in the Control Panel list, it has an icon of a coffee cup with steam. Select the Update tab then click the Update Now button. Click Yes to allow changes.

What is Update4j?

Overview. Update4j is the first auto-update and launcher library designed for Java 9+. Easily host your application files anywhere (even Google Drive, Dropbox, Amazon S3, or Maven Central) and you can synchronize them with all your distributed applications.


1 Answers

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.

like image 173
Stephen C Avatar answered Oct 14 '22 04:10

Stephen C