Package org.codehaus.groovy.tools

# Class RootLoader

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

All Implemented Interfaces:
  `Closeable`, `AutoCloseable`

public class RootLoader extends URLClassLoader
This ClassLoader should be used as root of class loaders. Any RootLoader does have its 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 `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 its 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) 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.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `RootLoader(ClassLoader parent)`
  Constructs a `RootLoader` without classpath.
  `RootLoader(URL[] urls, ClassLoader parent)`
  Constructs a `RootLoader` with a parent loader and an array of URLs as its classpath.
  `RootLoader(LoaderConfiguration lc)`
  Constructs a `RootLoader` with a `LoaderConfiguration` object which holds the classpath.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `addURL(URL url)`
  `protected Class<?>`
  `findClass(String name)`
  `URL`
  `getResource(String name)`
  `Enumeration<URL>`
  `getResources(String name)`
  `protected Class<?>`
  `loadClass(String name, boolean resolve)`

  ### Methods inherited from class java.net.URLClassLoader

  `close, definePackage, findResource, findResources, getPermissions, getResourceAsStream, getURLs, newInstance, newInstance`

  ### Methods inherited from class java.security.SecureClassLoader

  `defineClass, defineClass`

  ### Methods inherited from class java.lang.ClassLoader

  `clearAssertionStatus, defineClass, defineClass, defineClass, defineClass, definePackage, findClass, findLibrary, findLoadedClass, findResource, findSystemClass, getClassLoadingLock, getDefinedPackage, getDefinedPackages, getName, getPackage, getPackages, getParent, getPlatformClassLoader, getSystemClassLoader, getSystemResource, getSystemResourceAsStream, getSystemResources, getUnnamedModule, isRegisteredAsParallelCapable, loadClass, registerAsParallelCapable, resolveClass, resources, setClassAssertionStatus, setDefaultAssertionStatus, setPackageAssertionStatus, setSigners`

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### RootLoader

    public RootLoader(ClassLoader parent)
    Constructs a `RootLoader` without classpath.
    Parameters:
      `parent` - the parent Loader

  - ### RootLoader

    public RootLoader(URL[] urls, ClassLoader parent)
    Constructs a `RootLoader` with a parent loader and an array of URLs as its classpath.

  - ### RootLoader

    public RootLoader(LoaderConfiguration lc)
    Constructs a `RootLoader` with a `LoaderConfiguration` object which holds the classpath.

- ## Method Details

  - ### loadClass

    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException
    Overrides:
      `loadClass` in class `ClassLoader`
    Throws:
      `ClassNotFoundException`

  - ### getResource

    public URL getResource(String name)
    Overrides:
      `getResource` in class `ClassLoader`

  - ### getResources

    public Enumeration<URL> getResources(String name) throws IOException

    Collapses entries that resolve to the same canonical jar file so callers such as `ServiceLoader` don't see the same providers twice when the launcher's startup classpath and the `load` entries in `groovy-starter.conf` reference the same jar (GROOVY-11978).

    Overrides:
      `getResources` in class `ClassLoader`
    Throws:
      `IOException`

  - ### addURL

    public void addURL(URL url)
    Overrides:
      `addURL` in class `URLClassLoader`

  - ### findClass

    protected Class<?> findClass(String name) throws ClassNotFoundException
    Overrides:
      `findClass` in class `URLClassLoader`
    Throws:
      `ClassNotFoundException`