Package org.jboss.modules

Class ModuleClassLoader

java.lang.Object
java.lang.ClassLoader
org.jboss.modules.ConcurrentClassLoader
org.jboss.modules.ModuleClassLoader
public class ModuleClassLoader extends ConcurrentClassLoader
A module classloader. Instances of this class implement the complete view of classes and resources available in a module. Contrast with Module, which has API methods to access the exported view of classes and resources.

  • Field Details

  • Constructor Details

    • ModuleClassLoader

      protected ModuleClassLoader(ModuleClassLoader.Configuration configuration)
      Construct a new instance.
      Parameters:
      configuration - the module class loader configuration to use

  • Method Details

    • recalculate

      boolean recalculate()
      Recalculate the path maps for this module class loader.
      Returns:
      true if the paths were recalculated, or false if another thread finished recalculating before the calling thread

    • setResourceLoaders

      boolean setResourceLoaders(ResourceLoaderSpec[] resourceLoaders)
      Change the set of resource loaders for this module class loader, and recalculate the path maps.
      Parameters:
      resourceLoaders - the new resource loaders
      Returns:
      true if the paths were recalculated, or false if another thread finished recalculating before the calling thread

    • setResourceLoaders

      private boolean setResourceLoaders(Paths<ResourceLoader,ResourceLoaderSpec> paths, ResourceLoaderSpec[] resourceLoaders)

    • getLocalLoader

      LocalLoader getLocalLoader()
      Get the local loader which refers to this module class loader.
      Returns:
      the local loader

    • findClass

      protected final Class<?> findClass(String className, boolean exportsOnly, boolean resolve) throws ClassNotFoundException
      Find a class, possibly delegating to other loader(s). This method should never synchronize across a delegation method call of any sort. The default implementation always throws ClassNotFoundException.

      If a class is to be defined by this method, it should be done via one of the atomic defineOrLoadClass methods rather than defineClass() in order to avoid spurious exceptions.

      Overrides:
      findClass in class ConcurrentClassLoader
      Parameters:
      className - the class name
      exportsOnly - true if only exported classes should be considered
      resolve - true if the class should be linked after loading
      Returns:
      the class
      Throws:
      ClassNotFoundException - if the class is not found

    • getClassNotFoundExceptionMessage

      protected String getClassNotFoundExceptionMessage(String className, Module fromModule)
      Returns an exception message used when producing instances of ClassNotFoundException. This can be overridden by subclasses to customise the error message.
      Parameters:
      className - the name of the class which is missing
      fromModule - the module from which the class could not be found
      Returns:
      an exception message used when producing instances of ClassNotFoundException

    • loadClassLocal

      public Class<?> loadClassLocal(String className) throws ClassNotFoundException
      Load a class from this class loader.
      Parameters:
      className - the class name to load
      Returns:
      the loaded class or null if it was not found
      Throws:
      ClassNotFoundException - if an exception occurs while loading the class or its dependencies

    • loadClassLocal

      public Class<?> loadClassLocal(String className, boolean resolve) throws ClassNotFoundException
      Load a local class from this class loader.
      Parameters:
      className - the class name
      resolve - true to resolve the loaded class
      Returns:
      the loaded class or null if it was not found
      Throws:
      ClassNotFoundException - if an error occurs while loading the class

    • loadResourceLocal

      Resource loadResourceLocal(String root, String name)
      Load a local resource from a specific root from this module class loader.
      Parameters:
      root - the root name
      name - the resource name
      Returns:
      the resource, or null if it was not found

    • loadResourceLocal

      public List<Resource> loadResourceLocal(String name)
      Load a local resource from this class loader.
      Parameters:
      name - the resource name
      Returns:
      the list of resources

    • doDefineOrLoadClass

      private Class<?> doDefineOrLoadClass(String className, byte[] bytes, int off, int len, ProtectionDomain protectionDomain)

    • getProtectionDomain

      private ProtectionDomain getProtectionDomain(CodeSource codeSource)

    • defineClass

      private Class<?> defineClass(String name, ClassSpec classSpec, ResourceLoader resourceLoader)
      Define a class from a class name and class spec. Also defines any enclosing Package instances, and performs any sealed-package checks.
      Parameters:
      name - the class name
      classSpec - the class spec
      resourceLoader - the resource loader of the class spec
      Returns:
      the new class

    • preDefine

      protected void preDefine(ClassSpec classSpec, String className)
      A hook which is invoked before a class is defined.
      Parameters:
      classSpec - the class spec of the defined class
      className - the class to be defined

    • postDefine

      protected void postDefine(ClassSpec classSpec, Class<?> definedClass)
      A hook which is invoked after a class is defined.
      Parameters:
      classSpec - the class spec of the defined class
      definedClass - the class that was defined

    • definePackage

      private Package definePackage(String name, PackageSpec spec)
      Define a package from a package spec.
      Parameters:
      name - the package name
      spec - the package specification
      Returns:
      the new package

    • findLibrary

      protected final String findLibrary(String libname)
      Find a library from one of the resource loaders.
      Overrides:
      findLibrary in class ClassLoader
      Parameters:
      libname - the library name
      Returns:
      the full absolute path to the library

    • findResource

      public final URL findResource(String name, boolean exportsOnly)
      Find the resource with the given name and exported status.
      Overrides:
      findResource in class ConcurrentClassLoader
      Parameters:
      name - the resource name
      exportsOnly - true to consider only exported resources or false to consider all resources
      Returns:
      the resource URL
      See Also:

    • findResources

      public final Enumeration<URL> findResources(String name, boolean exportsOnly) throws IOException
      Finds the resources with the given name and exported status.
      Overrides:
      findResources in class ConcurrentClassLoader
      Parameters:
      name - the resource name
      exportsOnly - true to consider only exported resources or false to consider all resources
      Returns:
      the resource enumeration
      Throws:
      IOException - if an I/O error occurs
      See Also:

    • findResourceAsStream

      public final InputStream findResourceAsStream(String name, boolean exportsOnly)
      Finds the resource with the given name and exported status, returning the resource content as a stream.
      Overrides:
      findResourceAsStream in class ConcurrentClassLoader
      Parameters:
      name - the resource name
      exportsOnly - true to consider only exported resources or false to consider all resources
      Returns:
      the resource stream, or null if the resource is not found

    • getModule

      public final Module getModule()
      Get the module for this class loader.
      Returns:
      the module

    • toString

      public final String toString()
      Get a string representation of this class loader.
      Overrides:
      toString in class Object
      Returns:
      the string

    • getPaths

      Set<String> getPaths()

    • definePackage

      protected final Package definePackage(String name, String specTitle, String specVersion, String specVendor, String implTitle, String implVersion, String implVendor, URL sealBase) throws IllegalArgumentException
      Defines a package by name in this ConcurrentClassLoader. If the package was already defined, the existing package is returned instead.
      Overrides:
      definePackage in class ConcurrentClassLoader
      Parameters:
      name - the package name
      specTitle - the specification title
      specVersion - the specification version
      specVendor - the specification vendor
      implTitle - the implementation title
      implVersion - the implementation version
      implVendor - the implementation vendor
      sealBase - if not null, then this package is sealed with respect to the given code source URL
      Returns:
      the newly defined package, or the existing one if one was already defined
      Throws:
      IllegalArgumentException

    • getPackageByName

      protected final Package getPackageByName(String name)
      Perform the actual work to load a package which is visible to this class loader. By default, uses a simple parent-first delegation strategy.
      Overrides:
      getPackageByName in class ConcurrentClassLoader
      Parameters:
      name - the package name
      Returns:
      the package, or null if no such package is visible to this class loader

    • getPackages

      protected final Package[] getPackages()
      Get all defined packages which are visible to this class loader.
      Overrides:
      getPackages in class ConcurrentClassLoader
      Returns:
      the packages

    • setDefaultAssertionStatus

      public final void setDefaultAssertionStatus(boolean enabled)
      Overrides:
      setDefaultAssertionStatus in class ClassLoader

    • setPackageAssertionStatus

      public final void setPackageAssertionStatus(String packageName, boolean enabled)
      Overrides:
      setPackageAssertionStatus in class ClassLoader

    • setClassAssertionStatus

      public final void setClassAssertionStatus(String className, boolean enabled)
      Overrides:
      setClassAssertionStatus in class ClassLoader

    • clearAssertionStatus

      public final void clearAssertionStatus()
      Overrides:
      clearAssertionStatus in class ClassLoader

    • hashCode

      public final int hashCode()
      Overrides:
      hashCode in class Object

    • equals

      public final boolean equals(Object obj)
      Overrides:
      equals in class Object

    • clone

      protected final Object clone() throws CloneNotSupportedException
      Overrides:
      clone in class Object
      Throws:
      CloneNotSupportedException

    • finalize

      protected final void finalize() throws Throwable
      Overrides:
      finalize in class Object
      Throws:
      Throwable

    • getResourceLoaders

      ResourceLoader[] getResourceLoaders()

    • iterateResources

      public final Iterator<Resource> iterateResources(String startName, boolean recurse)
      Iterate the resources within this module class loader. Only resource roots which are inherently iterable will be checked, thus the result of this method may only be a subset of the actual loadable resources. The returned resources are not sorted or grouped in any particular way.
      Parameters:
      startName - the directory name to search
      recurse - true to recurse into subdirectories, false otherwise
      Returns:
      the resource iterator

    • getLocalPaths

      public final Set<String> getLocalPaths()
      Get the (unmodifiable) set of paths which are locally available in this module class loader. The set will include all paths defined by the module's resource loaders, minus any paths excluded by filters. The set will generally always contain an empty entry (""). The set is unordered and unsorted, and is iterable in O(n) time and accessible in O(1) time.
      Returns:
      the set of local paths