GroovyClassLoader (Groovy 5.0.0-SNAPSHOT)

groovy.lang.GroovyClassLoader

```
public class GroovyClassLoader
extends URLClassLoader
```
A ClassLoader which can load Groovy classes. The loaded classes are cached, classes from other classloaders should not be cached. To be able to load a script that was asked for earlier but was created later it is essential not to keep anything like a "class not found" information for that class name. This includes possible parent loaders. Classes that are not cached are always reloaded.

Nested Class Summary

Nested classes
Modifiers	Name	Description
`static class`	`GroovyClassLoader.ClassCollector`
`static class`	`GroovyClassLoader.InnerLoader`

Field Summary

Fields
Modifiers	Name	Description
`protected EvictableCache<String, Class>`	`classCache`	This cache contains the loaded classes or PARSING, if the class is currently parsed.
`protected StampedCommonCache<String, Class>`	`sourceCache`	This cache contains mappings of file name to class.

Constructor Summary

Constructors
Constructor and description
`GroovyClassLoader()` Creates a GroovyClassLoader using the current Thread's context ClassLoader as parent.
`GroovyClassLoader(ClassLoader parent)` Creates a GroovyClassLoader using the given ClassLoader as parent.
`GroovyClassLoader(GroovyClassLoader parent)` Creates a GroovyClassLoader using the given GroovyClassLoader as parent.
`GroovyClassLoader(ClassLoader parent, CompilerConfiguration config)` Creates a GroovyClassLoader using the given ClassLoader as parent.
`GroovyClassLoader(ClassLoader parent, CompilerConfiguration config, boolean useConfigurationClasspath)` Creates a GroovyClassLoader.

Methods Summary

Methods
Type Params	Return Type	Name and description
	`public void`	`addClasspath(String path)` adds a classpath to this classloader.
	`public void`	`addURL(URL url)` adds a URL to the classloader.
	`public void`	`clearCache()` Removes all classes from the class cache.
	`public void`	`close()` Closes this GroovyClassLoader and clears any caches it maintains.
	`protected GroovyClassLoader.ClassCollector`	`createCollector(CompilationUnit unit, SourceUnit su)` creates a ClassCollector for a new compilation.
	`protected CompilationUnit`	`createCompilationUnit(CompilerConfiguration config, CodeSource source)` creates a new CompilationUnit.
	`public Class`	`defineClass(String name, byte[] bytes)` Converts an array of bytes into an instance of `Class`.
	`public Class`	`defineClass(ClassNode classNode, String file, String newCodeBase)` Compiles the given `ClassNode` returning the resulting `Class`.
	`public String`	`genEncodingString(CharSequence chars)` Generates an encoded string based on the specified characters and the defined encoding algorithm.
	`public String`	`generateScriptName()`
	`protected Class`	`getClassCacheEntry(String name)` gets a class from the class cache.
	`protected String[]`	`getClassPath()` gets the currently used classpath.
	`public Class[]`	`getLoadedClasses()`
	`protected PermissionCollection`	`getPermissions(CodeSource codeSource)`
	`public GroovyResourceLoader`	`getResourceLoader()`
	`protected long`	`getTimeStamp(Class cls)` Gets the time stamp of a given class.
	`public boolean`	`hasCompatibleConfiguration(CompilerConfiguration config)` Checks if this class loader has compatible CompilerConfiguration with the provided one.
	`protected boolean`	`isRecompilable(Class cls)` Indicates if a class is recompilable.
	`public Boolean`	`isShouldRecompile()` gets the currently set recompilation mode. null means, the compiler configuration is used.
	`protected boolean`	`isSourceNewer(URL source, Class cls)` Decides if the given source is newer than a class.
	`public Class<?>`	`loadClass(String name)` {@inheritDoc}
	`protected Class<?>`	`loadClass(String name, boolean resolve)` Implemented here to check package access prior to returning an already-loaded class.
	`public Class`	`loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript)` Loads a class from a file or a parent loader.
	`public Class`	`loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript, boolean resolve)` Loads a class from a file or a parent loader.
	`public URL`	`loadGroovySource(String filename)`
	`public Class`	`parseClass(File file)` Parses the given file into a Java class capable of being run
	`public Class`	`parseClass(String text, String fileName)` Parses the given text into a Java class capable of being run
	`public Class`	`parseClass(String text)` Parses the given text into a Java class capable of being run
	`public Class`	`parseClass(Reader reader, String fileName)`
	`public Class`	`parseClass(GroovyCodeSource codeSource)`
	`public Class`	`parseClass(GroovyCodeSource codeSource, boolean shouldCacheSource)` Parses the given code source into a Java class.
	`protected Class`	`recompile(URL source, String className, Class oldClass)` (Re)Compiles the given source.
	`protected void`	`removeClassCacheEntry(String name)` removes a class from the class cache.
	`protected void`	`setClassCacheEntry(Class cls)` sets an entry in the class cache.
	`public void`	`setResourceLoader(GroovyResourceLoader resourceLoader)`
	`public void`	`setShouldRecompile(Boolean mode)` sets if the recompilation should be enabled.

Inherited Methods Summary

Inherited Methods
Methods inherited from class	Name
`class URLClassLoader`	newInstance, newInstance, findResource, getResourceAsStream, findResources, close, getURLs, getName, loadClass, getPlatformClassLoader, getSystemClassLoader, getSystemResourceAsStream, getSystemResource, getResource, getResources, getDefinedPackage, resources, isRegisteredAsParallelCapable, getSystemResources, getParent, getUnnamedModule, getDefinedPackages, setDefaultAssertionStatus, setPackageAssertionStatus, setClassAssertionStatus, clearAssertionStatus, wait, wait, wait, equals, toString, hashCode, getClass, notify, notifyAll

- Field Detail
  - protected final EvictableCache<String, Class> classCache
    
    This cache contains the loaded classes or PARSING, if the class is currently parsed.
  - protected final StampedCommonCache<String, Class> sourceCache
    
    This cache contains mappings of file name to class. It is used to bypass compilation.
- Constructor Detail
  - public GroovyClassLoader()
    
    Creates a GroovyClassLoader using the current Thread's context ClassLoader as parent.
  - public GroovyClassLoader(ClassLoader parent)
    
    Creates a GroovyClassLoader using the given ClassLoader as parent.
  - public GroovyClassLoader(GroovyClassLoader parent)
    
    Creates a GroovyClassLoader using the given GroovyClassLoader as parent. The new loader will get the parent's CompilerConfiguration.
  - public GroovyClassLoader(ClassLoader parent, CompilerConfiguration config)
    
    Creates a GroovyClassLoader using the given ClassLoader as parent.
  - public GroovyClassLoader(ClassLoader parent, CompilerConfiguration config, boolean useConfigurationClasspath)
    
    Creates a GroovyClassLoader.
    Parameters:
    parent - the parent class loader
    config - the compiler configuration
    useConfigurationClasspath - determines if the configurations classpath should be added
- Method Detail
  - public void addClasspath(String path)
    
    adds a classpath to this classloader.
    Parameters:
    path - is a jar file or a directory.
    See Also:
    addURL(URL)
  - @Override
    public void addURL(URL url)
    
    adds a URL to the classloader.
    Parameters:
    url - the new classpath element
  - public void clearCache()
    
    Removes all classes from the class cache.
    In addition to internal caches this method also clears any previously set MetaClass information for the given set of classes being removed.
    See Also:
    getClassCacheEntry(String)
    setClassCacheEntry(Class)
    removeClassCacheEntry(String)
  - @Override
    public void close()
    
    Closes this GroovyClassLoader and clears any caches it maintains.
    No use should be made of this instance after this method is invoked. Any classes that are already loaded are still accessible.
    throws:
    IOException
    
    See Also:
    URLClassLoader.close
    clearCache()
    Since:
    2.5.0
  - protected GroovyClassLoader.ClassCollector createCollector(CompilationUnit unit, SourceUnit su)
    
    creates a ClassCollector for a new compilation.
    Parameters:
    unit - the compilationUnit
    su - the SourceUnit
    Returns:
    the ClassCollector
  - protected CompilationUnit createCompilationUnit(CompilerConfiguration config, CodeSource source)
    
    creates a new CompilationUnit. If you want to add additional phase operations to the CompilationUnit (for example to inject additional methods, variables, fields), then you should overwrite this method.
    Parameters:
    config - the compiler configuration, usually the same as for this class loader
    source - the source containing the initial file to compile, more files may follow during compilation
    Returns:
    the CompilationUnit
  - public Class defineClass(String name, byte[] bytes)
    
    Converts an array of bytes into an instance of Class. Before the class can be used it must be resolved.
  - public Class defineClass(ClassNode classNode, String file, String newCodeBase)
    
    Compiles the given ClassNode returning the resulting Class.
    WARNING: compilation is not synchronized
  - public String genEncodingString(CharSequence chars)
    
    Generates an encoded string based on the specified characters and the defined encoding algorithm. Supported algorithms currently are "md5" and sha256". An exception is throw for an unknown algorithm or if the JVM doesn't support the algorithm.
    Parameters:
    chars - The characters to encode.
    Returns:
    The encoded string.
  - public String generateScriptName()
  - protected Class getClassCacheEntry(String name)
    
    gets a class from the class cache. This cache contains only classes loaded through this class loader or an InnerLoader instance. If no class is stored for a specific name, then the method should return null.
    Parameters:
    name - of the class
    Returns:
    the class stored for the given name
    See Also:
    removeClassCacheEntry(String)
    setClassCacheEntry(Class)
    clearCache()
  - protected String[] getClassPath()
    
    gets the currently used classpath.
    Returns:
    a String[] containing the file information of the urls
    See Also:
    getURLs()
  - public Class[] getLoadedClasses()
    
    Returns all Groovy classes loaded by this class loader.
    Returns:
    all classes loaded by this class loader
  - @Override
    protected PermissionCollection getPermissions(CodeSource codeSource)
  - public GroovyResourceLoader getResourceLoader()
  - protected long getTimeStamp(Class cls)
    
    Gets the time stamp of a given class. For groovy generated classes this usually means to return the value of the static field __timeStamp. If the parameter doesn't have such a field, then Long.MAX_VALUE is returned
    Parameters:
    cls - the class
    Returns:
    the time stamp
  - public boolean hasCompatibleConfiguration(CompilerConfiguration config)
    
    Checks if this class loader has compatible CompilerConfiguration with the provided one.
    Parameters:
    config - the compiler configuration to test for compatibility
    Returns:
    true if the provided config is exactly the same instance of CompilerConfiguration as this loader has
  - protected boolean isRecompilable(Class cls)
    
    Indicates if a class is recompilable. Recompilable means, that the classloader will try to locate a groovy source file for this class and then compile it again, adding the resulting class as entry to the cache. Giving null as class is like a recompilation, so the method should always return true here. Only classes that are implementing GroovyObject are compilable and only if the timestamp in the class is lower than Long.MAX_VALUE.
    NOTE: First the parent loaders will be asked and only if they don't return a class the recompilation will happen. Recompilation also only happen if the source file is newer.
    Parameters:
    cls - the class to be tested. If null the method should return true
    Returns:
    true if the class should be compiled again
    See Also:
    isSourceNewer(URL, Class)
  - public Boolean isShouldRecompile()
    
    gets the currently set recompilation mode. null means, the compiler configuration is used. False means no recompilation and true means that recompilation will be done if needed.
    Returns:
    the recompilation mode
  - protected boolean isSourceNewer(URL source, Class cls)
    
    Decides if the given source is newer than a class.
    throws:
    IOException if it is not possible to open a connection for the given source
    
    Parameters:
    source - the source we may want to compile
    cls - the former class
    Returns:
    true if the source is newer, false else
    See Also:
    getTimeStamp(Class)
  - @Override
    public Class<?> loadClass(String name)
    
    {@inheritDoc}
    See Also:
    ClassLoader#loadClass(java.lang.String,boolean)
  - @Override
    protected Class<?> loadClass(String name, boolean resolve)
    
    Implemented here to check package access prior to returning an already-loaded class.
    throws:
    ClassNotFoundException if class could not be found
    throws:
    CompilationFailedException if compilation of script failed
  - public Class loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript)
    
    Loads a class from a file or a parent loader. This method delegates to:
```
 loadClass(name, lookupScriptFiles, preferClassOverScript, false);
 
```
    throws:
    ClassNotFoundException if class could not be found
    throws:
    CompilationFailedException if compilation of script failed
  - @SuppressWarnings("removal")
    public Class loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript, boolean resolve)
    
    Loads a class from a file or a parent loader.
    throws:
    ClassNotFoundException if class could not be found
    throws:
    CompilationFailedException if compilation of script failed
    
    Parameters:
    name - of the class to be loaded
    lookupScriptFiles - if false no lookup at files is done at all
    preferClassOverScript - if true the file lookup is only done if there is no class
    resolve - see ClassLoader.loadClass
    Returns:
    the class found or the class created from a file lookup
  - @Override
    public URL loadGroovySource(String filename)
  - public Class parseClass(File file)
    
    Parses the given file into a Java class capable of being run
    Parameters:
    file - the file name to parse
    Returns:
    the main class defined in the given script
  - public Class parseClass(String text, String fileName)
    
    Parses the given text into a Java class capable of being run
    Parameters:
    text - the text of the script/class to parse
    fileName - the file name to use as the name of the class
    Returns:
    the main class defined in the given script
  - public Class parseClass(String text)
    
    Parses the given text into a Java class capable of being run
    Parameters:
    text - the text of the script/class to parse
    Returns:
    the main class defined in the given script
  - public Class parseClass(Reader reader, String fileName)
  - public Class parseClass(GroovyCodeSource codeSource)
  - public Class parseClass(GroovyCodeSource codeSource, boolean shouldCacheSource)
    
    Parses the given code source into a Java class. If there is a class file for the given code source, then no parsing is done, instead the cached class is returned.
    Parameters:
    shouldCacheSource - if true then the generated class will be stored in the source cache
    Returns:
    the main class defined in the given script
  - protected Class recompile(URL source, String className, Class oldClass)
    
    (Re)Compiles the given source. This method starts the compilation of a given source, if the source has changed since the class was created. For this isSourceNewer is called.
    throws:
    CompilationFailedException if the compilation failed
    throws:
    IOException if the source is not readable
    
    Parameters:
    source - the source pointer for the compilation
    className - the name of the class to be generated
    oldClass - a possible former class
    Returns:
    the old class if the source wasn't new enough, the new class else
    See Also:
    isSourceNewer(URL, Class)
  - protected void removeClassCacheEntry(String name)
    
    removes a class from the class cache.
    Parameters:
    name - of the class
    See Also:
    getClassCacheEntry(String)
    setClassCacheEntry(Class)
    clearCache()
  - protected void setClassCacheEntry(Class cls)
    
    sets an entry in the class cache.
    Parameters:
    cls - the class
    See Also:
    removeClassCacheEntry(String)
    getClassCacheEntry(String)
    clearCache()
  - public void setResourceLoader(GroovyResourceLoader resourceLoader)
  - public void setShouldRecompile(Boolean mode)
    
    sets if the recompilation should be enabled. There are 3 possible values for this. Any value different from null overrides the value from the compiler configuration. true means to recompile if needed false means to never recompile.
    Parameters:
    mode - the recompilation mode
    See Also:
    CompilerConfiguration

| Detail:
Field
Constructor
Method

[Java] Class GroovyClassLoader

Nested Class Summary

Field Summary

Constructor Summary

Methods Summary

Inherited Methods Summary

Field Detail

protected final EvictableCache<String, Class> classCache

protected final StampedCommonCache<String, Class> sourceCache

Constructor Detail

public GroovyClassLoader()

public GroovyClassLoader(ClassLoader parent)

public GroovyClassLoader(GroovyClassLoader parent)

public GroovyClassLoader(ClassLoader parent, CompilerConfiguration config)

public GroovyClassLoader(ClassLoader parent, CompilerConfiguration config, boolean useConfigurationClasspath)

Method Detail

public void addClasspath(String path)

@Overridepublic void addURL(URL url)

public void clearCache()

@Overridepublic void close()

protected GroovyClassLoader.ClassCollector createCollector(CompilationUnit unit, SourceUnit su)

protected CompilationUnit createCompilationUnit(CompilerConfiguration config, CodeSource source)

public Class defineClass(String name, byte[] bytes)

public Class defineClass(ClassNode classNode, String file, String newCodeBase)

public String genEncodingString(CharSequence chars)

public String generateScriptName()

protected Class getClassCacheEntry(String name)

protected String[] getClassPath()

public Class[] getLoadedClasses()

@Overrideprotected PermissionCollection getPermissions(CodeSource codeSource)

public GroovyResourceLoader getResourceLoader()

protected long getTimeStamp(Class cls)

public boolean hasCompatibleConfiguration(CompilerConfiguration config)

protected boolean isRecompilable(Class cls)

public Boolean isShouldRecompile()

protected boolean isSourceNewer(URL source, Class cls)

@Overridepublic Class<?> loadClass(String name)

@Overrideprotected Class<?> loadClass(String name, boolean resolve)

public Class loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript)

@SuppressWarnings("removal")public Class loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript, boolean resolve)

@Overridepublic URL loadGroovySource(String filename)

public Class parseClass(File file)

public Class parseClass(String text, String fileName)

public Class parseClass(String text)

public Class parseClass(Reader reader, String fileName)

public Class parseClass(GroovyCodeSource codeSource)

public Class parseClass(GroovyCodeSource codeSource, boolean shouldCacheSource)

protected Class recompile(URL source, String className, Class oldClass)

protected void removeClassCacheEntry(String name)

protected void setClassCacheEntry(Class cls)

public void setResourceLoader(GroovyResourceLoader resourceLoader)

public void setShouldRecompile(Boolean mode)

@Override
public void addURL(URL url)

@Override
public void close()

@Override
protected PermissionCollection getPermissions(CodeSource codeSource)

@Override
public Class<?> loadClass(String name)

@Override
protected Class<?> loadClass(String name, boolean resolve)

@SuppressWarnings("removal")
public Class loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript, boolean resolve)

@Override
public URL loadGroovySource(String filename)