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.