Question

I’m having some hard time with Java classloaders, maybe somebody could shed some light on this. I have extracted the essence of the problem to the follwing:

There are three classes – ClassLoaderTest, LoadedClass and LoadedClassDep. They are all on different paths.

ClassLoaderTest instantiates a new URLClassLoader – myClassLoader, priming it with the paths to the remaining two classes and it’s own classloader (i.e. the application classloader) as parent. It then uses Class.forName("com.example.LoadedClass", true, myClassLoader) to load the LoadedClass through reflection. The LoadedClass imports the LoadedClassDep. If I run the above, using:

java -cp /path/to/the/ClassLoaderTest ClassLoaderTest "/path/to/LoadedClass" "/path/to/LoadedClassDep"

and using the command line arguments to prime the URLClassLoader everything works fine. Using static initialisers I confirm that the two classes are loaded with an instance of a URLClassLoader.
HOWEVER, and this is the problem, if I do:

java -cp /path/to/the/ClassLoaderTest:/path/to/the/LoadedClass ClassLoaderTest "/path/to/LoadedClassDep"

this fails to load the LoadedClassDep (ClassNotFoundException). The LoadedClass is loaded correctly, but with sun.misc.Launcher$AppClassLoader, not the URLClassLoader!
It would appear that since the application classloader is capable of loading the LoadedClass it also attempts to load the LoadedClassDep, disregarding the URLClassLoader.

Here’s the full source code:

package example.bc;
public class ClassloaderTest {
    public static void main(String[] args) {
        new ClassloaderTest().run(args);
    }

    private void run(String[] args) {
        URLClassLoader myClasLoader = initClassLoader(args);
        try {
            Class<?> cls = Class.forName("com.example.bc.LoadedClass", true, myClasLoader);
            Object obj = cls.newInstance();
            cls.getMethod("call").invoke(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private URLClassLoader initClassLoader(String[] args) {
        URL[] urls = new URL[args.length];

        try {
            for (int i = 0; i < args.length; i++) {
                urls[i] = new File(args[i]).toURI().toURL();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
        return new URLClassLoader(urls, getClass().getClassLoader());
    }
}

package com.example.bc;

import com.bc.LoadedClassDep;

public class LoadedClass {

    static {
        System.out.println("LoadedClass " + LoadedClass.class.getClassLoader().getClass());
    }

    public void call() {
        new LoadedClassDep();
    }
}

package com.bc;

public class LoadedClassDep {
    static {
        System.out.println("LoadedClassDep " + LoadedClassDep.class.getClassLoader().getClass());
    }
}

I hope I made this clear enough. My issue is, I only know the path to ClassLoadeTest at compile time, I have to use strings at runtime for the other paths. So, any ideas how to make the second scenario work?

Answer 1

I’d expect the application classloader to load LoadedClass in the second case, since classloaders delegate to their parent initially – this is the standard behaviour. In the second case, LoadedClass is on the parent’s classpath, so it loads the class instead of giving up and letting the URLClassLoader try.

The application classloader then attempts to load the LoadedClassDep because it is imported and referenced directly in LoadedClass:

public void call() {
    new LoadedClassDep();
}

If you need to load these classes dynamically and independently at runtime, you can’t have direct references between them in this way.

It is also possible to change the order in which classloaders are tried – see Java classloaders: why search the parent classloader first? for some discussion of this.