public class GroovyClassLoader extends URLClassLoader
| Modifier and Type | Class and Description | 
|---|---|
| static class  | GroovyClassLoader.ClassCollector | 
| static class  | GroovyClassLoader.InnerLoader | 
| Modifier and Type | Field and Description | 
|---|---|
| protected Map<String,Class> | classCachethis cache contains the loaded classes or PARSING, if the class is currently parsed | 
| protected Map<String,Class> | sourceCacheThis cache contains mappings of file name to class. | 
| Constructor and Description | 
|---|
| GroovyClassLoader()creates a GroovyClassLoader using the current Thread's context
 Class loader as parent. | 
| GroovyClassLoader(ClassLoader loader)creates a GroovyClassLoader using the given ClassLoader as parent | 
| GroovyClassLoader(ClassLoader loader,
                 CompilerConfiguration config)creates a GroovyClassLoader using the given ClassLoader as parent. | 
| GroovyClassLoader(ClassLoader parent,
                 CompilerConfiguration config,
                 boolean useConfigurationClasspath)creates a GroovyClassLoader. | 
| GroovyClassLoader(GroovyClassLoader parent)creates a GroovyClassLoader using the given GroovyClassLoader as parent. | 
| Modifier and Type | Method and Description | 
|---|---|
| void | addClasspath(String path)adds a classpath to this classloader. | 
| void | addURL(URL url)adds a URL to the classloader. | 
| void | clearCache()Removes all classes from the class cache. | 
| 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. | 
| Class | defineClass(ClassNode classNode,
           String file,
           String newCodeBase)Loads the given class node returning the implementation Class. | 
| Class | defineClass(String name,
           byte[] b)open up the super class define that takes raw bytes | 
| String | generateScriptName() | 
| protected Class | getClassCacheEntry(String name)gets a class from the class cache. | 
| protected String[] | getClassPath()gets the currently used classpath. | 
| Class[] | getLoadedClasses()Returns all Groovy classes loaded by this class loader. | 
| protected PermissionCollection | getPermissions(CodeSource codeSource) | 
| GroovyResourceLoader | getResourceLoader() | 
| protected long | getTimeStamp(Class cls)gets the time stamp of a given class. | 
| protected boolean | isRecompilable(Class cls)Indicates if a class is recompilable. | 
| Boolean | isShouldRecompile()gets the currently set recompilation mode. | 
| protected boolean | isSourceNewer(URL source,
             Class cls)Decides if the given source is newer than a class. | 
| Class<?> | loadClass(String name) | 
| protected Class | loadClass(String name,
         boolean resolve)Implemented here to check package access prior to returning an
 already loaded class. | 
| Class | loadClass(String name,
         boolean lookupScriptFiles,
         boolean preferClassOverScript)loads a class from a file or a parent classloader. | 
| Class | loadClass(String name,
         boolean lookupScriptFiles,
         boolean preferClassOverScript,
         boolean resolve)loads a class from a file or a parent classloader. | 
| Class | parseClass(File file)Parses the given file into a Java class capable of being run | 
| Class | parseClass(GroovyCodeSource codeSource) | 
| Class | parseClass(GroovyCodeSource codeSource,
          boolean shouldCacheSource)Parses the given code source into a Java class. | 
| Class | parseClass(InputStream in,
          String fileName)Deprecated. 
 Prefer using methods taking a Reader rather than an InputStream to avoid wrong encoding issues. | 
| Class | parseClass(String text)Parses the given text into a Java class capable of being run | 
| Class | parseClass(String text,
          String fileName)Parses the given text into a Java class capable of being run | 
| 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. | 
| void | setResourceLoader(GroovyResourceLoader resourceLoader) | 
| void | setShouldRecompile(Boolean mode)sets if the recompilation should be enable. | 
close, definePackage, findClass, findResource, findResources, getResourceAsStream, getURLs, newInstance, newInstancedefineClass, defineClassclearAssertionStatus, defineClass, defineClass, defineClass, defineClass, definePackage, findLibrary, findLoadedClass, findSystemClass, getClassLoadingLock, getPackage, getPackages, getParent, getResource, getResources, getSystemClassLoader, getSystemResource, getSystemResourceAsStream, getSystemResources, registerAsParallelCapable, resolveClass, setClassAssertionStatus, setDefaultAssertionStatus, setPackageAssertionStatus, setSignersprotected final Map<String,Class> classCache
public GroovyClassLoader()
public GroovyClassLoader(ClassLoader loader)
public GroovyClassLoader(GroovyClassLoader parent)
public GroovyClassLoader(ClassLoader parent, CompilerConfiguration config, boolean useConfigurationClasspath)
parent - the parent class loaderconfig - the compiler configurationuseConfigurationClasspath - determines if the configurations classpath should be addedpublic GroovyClassLoader(ClassLoader loader, CompilerConfiguration config)
public void setResourceLoader(GroovyResourceLoader resourceLoader)
public GroovyResourceLoader getResourceLoader()
public Class defineClass(ClassNode classNode, String file, String newCodeBase)
WARNING: this compilation is not synchronized
classNode - public Class parseClass(File file) throws CompilationFailedException, IOException
file - the file name to parseCompilationFailedExceptionIOExceptionpublic Class parseClass(String text, String fileName) throws CompilationFailedException
text - the text of the script/class to parsefileName - the file name to use as the name of the classCompilationFailedExceptionpublic Class parseClass(String text) throws CompilationFailedException
text - the text of the script/class to parseCompilationFailedExceptionpublic String generateScriptName()
@Deprecated public Class parseClass(InputStream in, String fileName) throws CompilationFailedException
CompilationFailedExceptionpublic Class parseClass(GroovyCodeSource codeSource) throws CompilationFailedException
CompilationFailedExceptionpublic Class parseClass(GroovyCodeSource codeSource, boolean shouldCacheSource) throws CompilationFailedException
shouldCacheSource - if true then the generated class will be stored in the source cacheCompilationFailedExceptionprotected String[] getClassPath()
URLClassLoader.getURLs()protected PermissionCollection getPermissions(CodeSource codeSource)
getPermissions in class URLClassLoaderprotected CompilationUnit createCompilationUnit(CompilerConfiguration config, CodeSource source)
config - the compiler configuration, usually the same as for this class loadersource - the source containing the initial file to compile, more files may follow during compilationprotected GroovyClassLoader.ClassCollector createCollector(CompilationUnit unit, SourceUnit su)
unit - the compilationUnitsu - the SourceUnitpublic Class defineClass(String name, byte[] b)
public Class loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript) throws ClassNotFoundException, CompilationFailedException
CompilationFailedException - if compilation was not successfulClassNotFoundExceptionprotected Class getClassCacheEntry(String name)
name - of the classremoveClassCacheEntry(String), 
setClassCacheEntry(Class), 
clearCache()protected void setClassCacheEntry(Class cls)
cls - the classremoveClassCacheEntry(String), 
getClassCacheEntry(String), 
clearCache()protected void removeClassCacheEntry(String name)
name - of the classgetClassCacheEntry(String), 
setClassCacheEntry(Class), 
clearCache()public void addURL(URL url)
addURL in class URLClassLoaderurl - the new classpath elementprotected boolean isRecompilable(Class cls)
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.
cls - the class to be tested. If null the method should return trueisSourceNewer(URL, Class)public void setShouldRecompile(Boolean mode)
mode - the recompilation modeCompilerConfigurationpublic Boolean isShouldRecompile()
public Class loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript, boolean resolve) throws ClassNotFoundException, CompilationFailedException
name - of the class to be loadedlookupScriptFiles - if false no lookup at files is done at allpreferClassOverScript - if true the file lookup is only done if there is no classresolve - see ClassLoader.loadClass(java.lang.String, boolean)ClassNotFoundException - if the class could not be foundCompilationFailedException - if the source file could not be compiledprotected Class recompile(URL source, String className, Class oldClass) throws CompilationFailedException, IOException
source - the source pointer for the compilationclassName - the name of the class to be generatedoldClass - a possible former classCompilationFailedException - if the compilation failedIOException - if the source is not readableisSourceNewer(URL, Class)public Class<?> loadClass(String name) throws ClassNotFoundException
loadClass in class ClassLoaderClassNotFoundExceptionprotected Class loadClass(String name, boolean resolve) throws ClassNotFoundException
loadClass in class ClassLoaderCompilationFailedException - if the compilation failedClassNotFoundException - if the class was not foundClassLoader.loadClass(java.lang.String, boolean)protected long getTimeStamp(Class cls)
cls - the classprotected boolean isSourceNewer(URL source, Class cls) throws IOException
source - the source we may want to compilecls - the former classIOException - if it is not possible to open an
                     connection for the given sourcegetTimeStamp(Class)public void addClasspath(String path)
path - is a jar file or a directory.addURL(URL)public Class[] getLoadedClasses()
Returns all Groovy classes loaded by this class loader.
public void clearCache()