| java.net.URLClassLoader
 groovy.lang.GroovyClassLoader
All known Subclasses: org.codehaus.groovy.classgen.DumpingClassLoader,
| GroovyClassLoader | | public class GroovyClassLoader extends URLClassLoader (Code) | | A ClassLoader which can load Groovy classes. The loaded classes are cached,
classes from other classlaoders 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 chached are always
reloaded.
author:
James Strachan
author:
Guillaume Laforge
author:
Steve Goetze
author:
Bing Ran
author:
Scott Stirling
author:
Jochen Theodorou
version:
$Revision: 4445 $ |
| Method Summary | |
| 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. | | protected 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(ClassNode classNode, String file)
| | public Class | defineClass(ClassNode classNode, String file, String newCodeBase)
Loads the given class node returning the implementation Class. | | protected Class | defineClass(String name, byte[] bytecode, ProtectionDomain domain)
A helper method to allow bytecode to be loaded. | | public Class | defineClass(String name, byte[] b)
| | protected void | expandClassPath(List pathList, String base, String classpath, boolean isManifestClasspath)
| | public synchronized 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()
Returns all Groovy classes loaded by this class loader. | | public 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. | | public 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. | | public Class | loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript)
loads a class from a file or a parent classloader. | | public Class | loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript, boolean resolve)
loads a class from a file or a parent classloader. | | protected Class | loadClass(String name, boolean resolve)
Implemented here to check package access prior to returning an
already loaded class. | | public Class | parseClass(File file)
| | public Class | parseClass(String text, String fileName)
| | public Class | parseClass(String text)
| | public Class | parseClass(InputStream in)
| | public Class | parseClass(InputStream in, 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)Comipiles 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 enable. |
| classCache | | protected Map classCache(Code) | | this cache contains the loaded classes or PARSING, if the class is currently parsed
|
| GroovyClassLoader | | public GroovyClassLoader()(Code) | | creates a GroovyClassLoader using the current Thread's context
Class loader as parent.
|
| GroovyClassLoader | | public GroovyClassLoader(ClassLoader loader)(Code) | | creates a GroovyClassLoader using the given ClassLoader as parent
|
| GroovyClassLoader | | public GroovyClassLoader(GroovyClassLoader parent)(Code) | | creates a GroovyClassLoader using the given GroovyClassLoader as parent.
This loader will get the parent's CompilerConfiguration
|
| GroovyClassLoader | | public GroovyClassLoader(ClassLoader parent, CompilerConfiguration config, boolean useConfigurationClasspath)(Code) | | creates a GroovyClassLaoder.
Parameters:
parent - the parten class loader
Parameters:
config - the compiler configuration
Parameters:
useConfigurationClasspath - determines if the configurations classpath should be added |
| addURL | | public void addURL(URL url)(Code) | | adds a URL to the classloader.
Parameters:
url - the new classpath element |
| createCollector | | protected ClassCollector createCollector(CompilationUnit unit, SourceUnit su)(Code) | | creates a ClassCollector for a new compilation.
Parameters:
unit - the compilationUnit
Parameters:
su - the SoruceUnit the ClassCollector |
| createCompilationUnit | | protected CompilationUnit createCompilationUnit(CompilerConfiguration config, CodeSource source)(Code) | | 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
Parameters:
source - the source containing the initial file to compile, more files may follow during compilation the CompilationUnit |
| defineClass | | public Class defineClass(ClassNode classNode, String file)(Code) | | Loads the given class node returning the implementation Class
Parameters:
classNode - a class |
| defineClass | | public Class defineClass(ClassNode classNode, String file, String newCodeBase)(Code) | | Loads the given class node returning the implementation Class.
WARNING: this compilation is not synchronized
Parameters:
classNode - a class |
| defineClass | | protected Class defineClass(String name, byte[] bytecode, ProtectionDomain domain)(Code) | | A helper method to allow bytecode to be loaded. spg changed name to
defineClass to make it more consistent with other ClassLoader methods
|
| defineClass | | public Class defineClass(String name, byte[] b)(Code) | | open up the super class define that takes raw bytes
|
| expandClassPath | | protected void expandClassPath(List pathList, String base, String classpath, boolean isManifestClasspath)(Code) | | expands the classpath
Parameters:
pathList - an empty list that will contain the elements of the classpath
Parameters:
classpath - the classpath specified as a single string |
| generateScriptName | | public synchronized String generateScriptName()(Code) | | |
| getLoadedClasses | | public Class[] getLoadedClasses()(Code) | | Returns all Groovy classes loaded by this class loader.
all classes loaded by this class loader |
| getTimeStamp | | protected long getTimeStamp(Class cls)(Code) | | 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 the time stamp |
| isRecompilable | | protected boolean isRecompilable(Class cls)(Code) | | Indicates if a class is recompilable. Recompileable 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 compileable 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.
See Also: GroovyClassLoader.isSourceNewer(URL,Class)
Parameters:
cls - the class to be tested. If null the method should return true true if the class should be compiled again |
| isShouldRecompile | | public Boolean isShouldRecompile()(Code) | | 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.
the recompilation mode |
| isSourceNewer | | protected boolean isSourceNewer(URL source, Class cls) throws IOException(Code) | | Decides if the given source is newer than a class.
See Also: GroovyClassLoader.getTimeStamp(Class)
Parameters:
source - the source we may want to compile
Parameters:
cls - the former class true if the source is newer, false else
throws:
IOException - if it is not possible to open anconnection for the given source |
| loadClass | | public Class loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript, boolean resolve) throws ClassNotFoundException, CompilationFailedException(Code) | | loads a class from a file or a parent classloader.
Parameters:
name - of the class to be loaded
Parameters:
lookupScriptFiles - if false no lookup at files is done at all
Parameters:
preferClassOverScript - if true the file lookup is only done if there is no class
Parameters:
resolve - @see ClassLoader#loadClass(java.lang.String, boolean) the class found or the class created from a file lookup
throws:
ClassNotFoundException - |
| parseClass | | public Class parseClass(String text, String fileName) throws CompilationFailedException(Code) | | Parses the given text into a Java class capable of being run
Parameters:
text - the text of the script/class to parse
Parameters:
fileName - the file name to use as the name of the class the main class defined in the given script |
| parseClass | | public Class parseClass(String text) throws CompilationFailedException(Code) | | Parses the given text into a Java class capable of being run
Parameters:
text - the text of the script/class to parse the main class defined in the given script |
| parseClass | | public Class parseClass(GroovyCodeSource codeSource, boolean shouldCacheSource) throws CompilationFailedException(Code) | | 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 the main class defined in the given script |
| recompile | | protected Class recompile(URL source, String className, Class oldClass) throws CompilationFailedException, IOException(Code) | | (Re)Comipiles 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.
See Also: GroovyClassLoader.isSourceNewer(URL,Class)
Parameters:
source - the source pointer for the compilation
Parameters:
className - the name of the class to be generated
Parameters:
oldClass - a possible former class the old class if the source wasn't new enough, the new class else
throws:
CompilationFailedException - if the compilation failed
throws:
IOException - if the source is not readable |
| setShouldRecompile | | public void setShouldRecompile(Boolean mode)(Code) | | sets if the recompilation should be enable. There are 3 possible
values for this. Any value different than 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 |
|
|