org.codehaus.groovy.tools: public class: RootLoader

org.codehaus.groovy.tools
public class: RootLoader [javadoc | source]

java.lang.Object
   java.lang.ClassLoader
      java.security.SecureClassLoader
         java.net.URLClassLoader
            org.codehaus.groovy.tools.RootLoader

This ClassLoader should be used as root of class loaders. Any RootLoader does have it's own classpath. When searching for a class or resource this classpath will be used. Parent Classloaders are ignored first. If a class or resource can't be found in the classpath of the RootLoader, then parent is checked.

Note: this is very against the normal behavior of classloaders. Normal is to first check parent and then look in the resources you gave this classloader.

It's possible to add urls to the classpath at runtime through

Also see:

For example:

parentLoader (has classpath: a.jar;c.jar)
|
|
childLoader (has classpath: a.jar;b.jar;c.jar)

class C (from c.jar) extends B (from b.jar)

childLoader.find("C") --> parentLoader does know C.class, try to load it --> to load C.class it has to load B.class --> parentLoader is unable to find B.class in a.jar or c.jar --> NoClassDefFoundException!

if childLoader had tried to load the class by itself, there would be no problem. Changing childLoader to be a RootLoader instance will solve that problem.'>addURL(URL)

Why using RootLoader? If you have to load classes with multiple classloaders and a classloader does know a class which depends on a class only a child of this loader does know, then you won't be able to load the class. To load the class the child is not allowed to redirect it's search for the class to the parent first. That way the child can load the class. If the child does not have all classes to do this, this fails of course.

For example:

parentLoader (has classpath: a.jar;c.jar)
|
|
childLoader (has classpath: a.jar;b.jar;c.jar)

class C (from c.jar) extends B (from b.jar)

if childLoader had tried to load the class by itself, there would be no problem. Changing childLoader to be a RootLoader instance will solve that problem.

author: Jochen - Theodorou

Constructor:
public RootLoader(LoaderConfiguration lc) { this(chooseParent()); Thread.currentThread().setContextClassLoader(this); URL[] urls = lc.getClassPathUrls(); for (int i = 0; i < urls.length; i++) { addURL(urls[i]); } } constructs a new RootLoader with a @see LoaderConfiguration object which holds the classpath
public RootLoader(URL[] urls, ClassLoader parent) { super(urls, parent); // major hack here...! try{ customClasses.put("org.w3c.dom.Node",super.loadClass("org.w3c.dom.Node",false)); } catch (Exception e) {} } constructs a new RootLoader with a parent loader and an array of URLs as classpath

Constructor:

 public RootLoader(LoaderConfiguration lc) {
        this(chooseParent());
        Thread.currentThread().setContextClassLoader(this);
        URL[] urls = lc.getClassPathUrls();
        for (int i = 0; i <  urls.length; i++) {
            addURL(urls[i]);
        }
}

constructs a new RootLoader with a @see LoaderConfiguration object which holds the classpath

 public RootLoader(URL[] urls,
    ClassLoader parent) {
        super(urls, parent);
        // major hack here...!
        try{
            customClasses.put("org.w3c.dom.Node",super.loadClass("org.w3c.dom.Node",false));
        } catch (Exception e) {}
}

constructs a new RootLoader with a parent loader and an array of URLs as classpath

Method from org.codehaus.groovy.tools.RootLoader Summary:
addURL, findClass, getResource, loadClass

Methods from java.net.URLClassLoader:
findResource, findResources, getURLs, newInstance, newInstance

Methods from java.lang.ClassLoader:
clearAssertionStatus, getParent, getResource, getResourceAsStream, getResources, getSystemClassLoader, getSystemResource, getSystemResourceAsStream, getSystemResources, loadClass, setClassAssertionStatus, setDefaultAssertionStatus, setPackageAssertionStatus

Methods from java.lang.Object:
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method from org.codehaus.groovy.tools.RootLoader Detail:
public void addURL(URL url) { super.addURL(url); } adds an url to the classpath of this classloader
protected Class findClass(String name) throws ClassNotFoundException { throw new ClassNotFoundException(name); }
public URL getResource(String name) { URL url = findResource(name); if (url == null) url = super.getResource(name); return url; } returns the URL of a resource, or null if it is not found
protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException { Class c = this.findLoadedClass(name); if (c != null) return c; c = (Class) customClasses.get(name); if (c != null) return c; try { c = oldFindClass(name); } catch (ClassNotFoundException cnfe) { // IGNORE } if (c == null) c = super.loadClass(name, resolve); if (resolve) resolveClass(c); return c; } loads a class using the name of the class

Method from org.codehaus.groovy.tools.RootLoader Detail:

 public  void addURL(URL url) {
        super.addURL(url);
}

adds an url to the classpath of this classloader

 protected Class findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
}

 public URL getResource(String name) {
        URL url = findResource(name);
        if (url == null) url = super.getResource(name);
        return url;
}

returns the URL of a resource, or null if it is not found

 protected Class loadClass(String name,
    boolean resolve) throws ClassNotFoundException {
        Class c = this.findLoadedClass(name);
        if (c != null) return c;
        c = (Class) customClasses.get(name);
        if (c != null) return c;
        try {
            c = oldFindClass(name);
        } catch (ClassNotFoundException cnfe) {
            // IGNORE
        }
        if (c == null) c = super.loadClass(name, resolve);
        if (resolve) resolveClass(c);
        return c;
}

loads a class using the name of the class