How to use class loaders?

Question

Hi all,
I wrote a very simple plugin engine. What I would like to do is allow for each plugin loaded, to be done in such a manner that it can be unloaded and/or reloaded at runtime without the entire application bein restarted. I know this is possible as I have seen some app servers that allow this. Basically, I want to make sure that when I null out the class loader, that the class is removed from memory. How I am testing this is simple. Load a plugin which adds a menu item. Attempt to unload the class (via nulling the class loader), and clicking on the menu item. This would normally go into the class loaded, but if it is unloaded, then it should throw some sort of exception (is this correct?). Below is what I have to load a plugin. The goal here is to be able to load a plugin with its own classloader, so that I can unload it later while not having to shut down the application. Also, one thing I am confused on. It seems no matter what I use for the URL object (in the try..catch block when creating it), it always finds my plugins with the path attribute I pass in. So I am a bit confused as to what the purpose of the String argument for the URL constructor is for. Lastly, reading the API for ClassLoader and methods like findClass, loadClass, etc, it seems that it will ALWAYS go to the parent class loader first to try to load the class. If the parent is null (as is in this case because I am creating a new class loader each time a plugin is to be loaded), it uses the bootstrap loader, which is the JVM loader. The problem I have with this is how do you force the loader to be the one you are creating, and not the JVM loader. I don't kow if the JVM loader is able to find my class or not, but I assume it is finding it because the URL constructor seems to take in anything and still find my plugin classes. So I am wondering if there is a better way to enforce or ensure that each new URLClassLoader instance is infact in control of the class it loads, and not the JVM class loader which would make it impossible to unload a single class.
public boolean loadPlugin(String path)
URL urls[] = new URL[1];
try
urls[0] = new URL("file://" + path);
catch(MalformedURLException murle)
System.out.println("Malformed URL");
URLClassLoader loader = new URLClassLoader(urls);
try
Plugin plugin = (Plugin)loader.loadClass(path).newInstance();
plugin.init(this); // add menu item.
loader = null; // attempt to unload class
return true;
catch(Exception e)
e.printStackTrace(System.out);
return false;
}

Answer 1

Basically, I want to make
sure that when I null out the class loader, that the
class is removed from memory.The class is removed from memory when it is garbage, i.e. when there are no references to it left.
Note that:
- Every instance (i.e. object) of the class holds a reference to its class object.
- The classloader that loaded the class holds a reference to the class object.
Load a plugin which adds a menu item. Attempt
to unload the class (via nulling the class loader),
and clicking on the menu item.Obviously the class can't be unloaded while the menu item has a reference to an object of the class.
Also, one thing I
am confused on. It seems no matter what I use for the
URL object (in the try..catch block when creating it),
it always finds my plugins with the path attribute I
pass in.This obviously means that the bootstrap classloader finds your class. Remove the class from your classpath e.g. by moving it to a subdirectory.
Here is some sample code that should work. This is meant as a proof of concept, you probably want to do some things differently. I'm also writing this from the top of my head, so I can't guarantee that there are no errors here.//this file (Plugin.java) should be in your classpath
public interface Plugin {
    //method declarations
}---//this file (MyPlugin.java) must NOT be in your classpath
public class MyPlugin implements Plugin {
    //methods
}---//this file (MainClass.java) should be in your classpath
//this is the main program
//import stuff (e.g. URLClassLoader)
public class MainClass {
    private ClassLoader loader;
    private Class plugin_class;
    private URL[] plugin_path; //set this
    public static void main(String[] args) {
        MainClass mc=new MainClass();
        //load an instance of the plugin
        Plugin p1=mc.getPlugin();
        //now modify the "MyPlugin.class" file
        //then you must load the new MyPlugin class
        mc.reloadPlugin();
        //load an instance of the new plugin
        Plugin p2=mc.getPlugin();
        //now p1 is the old MyPlugin and p2 the new MyPlugin
        //if we don't need the old plugin anymore we can do this
        p1=null;
        //Now there are no more references to the old
        //plugin class so it (and its classloader object)
        //may be removed by the garbage collector
    public MainClass() {
        reloadPlugin();
    public Plugin getPlugin() {
        return (Plugin)plugin_class.newInstance();
    public void reloadPlugin() {
        loader=new URLClassLoader(plugin_path);
        plugin_class=Class.forName("MyPlugin", true, loader);
}Now, for the sake of argument, suppose that we would change MainClass.getPlugin() to this:    public MyPlugin getPlugin() {
        return (MyPlugin)plugin_class.newInstance();
    }Now MainClass uses MyPlugin so the MyPlugin class will be loaded when the MainClass class is loaded. However, this is not at all what we want.
If we change it back to the way it was we notice that when the MainClass class is loaded then only the Plugin (interface) class is loaded. This way the MyPlugin class won't be loaded until we load it manually through our own classloader, and this is exactly what we want.
This is why we usually handle all dynamically reloadable classes through interfaces instead of using the classes directly.
- Marcus