"Smart update" question or how to overwrite the library in current use

Question

Hello,
I would like to add a "smartUpdate" feature to an application i.e.
1. Read an updated library from the web (e.g. as archive- zip)
2. Extract files from archive and write them to a local drive.
3. After all the files are written, close the appliaction and restart it.
#1 is easy enough, there problems is with #2 and #3.
I will need to overwrite jar file that the running application is using.
Does anybody has experience with this. Any ideas how to do this.
Thank you.
Leo

Answer 1

Appreciate any other ideas...If you have to exchange classes in an application while it is still running, this will always be a bit tricky (if not
impossible). It is much easiser to close and restart the application (= make the OS call the Java-interpreter again). But if you decide, that restarting from the OS is not possible, there is some work to do :-)
There are three main problems:
1. If your classes are loaded from Jar-files, the Jar-files will be locked by the java-process. Once a class has been loaded from a Jar-file, that file is write-protected
2. Java will not reload a class that it has already loaded, even if the Class- or Jar-File has changed
3. Even if the class would be reloaded, this could not affect any instances of these classes.
Problems 1 and 2 can be solved by using a custom ClassLoader (this is still 100% pure Java, no hack or
something).
This custom ClassLoader could be written in a way that it could close the Jar-Files on demand (closing the Jar-File every time a class has been loaded would slow down class loading significantly).
To force reloading (=using the new jar-file) you would have to instantiate a new ClassLoader (= another instance of your own custom ClassLoader). This new ClassLoader will use the new versions.
The third problem is just a matter of your application; you must ensure that it re-instantiates everything with the new ClassLoader.
So, it would be something like:
//Create custom CLassLoader
MyClassLoader cl = new MyClassLoader();
//--- start update code (assuming my.package.MyClass1.main will receive the new jar-file)
Class mc = cl.loadClass( "my.package.MyClass1");
Method main = mc.getMethod( "main", new Class[]{ String[].class } );
main.invoke( null, new Object[]{ new String[0] } );
//--- overcome write-protection
cl.closeFiles();
//--- now copy the new Jar-File into the appropriate directory
//--- dispose first ClassLoader and create a new one
cl = new MyClassLoader();
//--- start app (assuming my.package.MyClass2.main is the "real" application)
Class mc = cl.loadClass( "my.package.MyClass1");
Method main = mc.getMethod( "main", new Class[]{ String[].class } );
main.invoke( null, new Object[]{ new String[0] } );All this ClassLoader stuff is a bit tricky, but this kind of "smart update", where you exchange classes while the VM is still running, is not a trivial problem (though
it's quite common if you're write application servers).
HTH
Matthias