|
| |
|
| java.lang.Object
 bsh.BshClassManager
bsh.classpath.ClassManagerImpl
| ClassManagerImpl | | public class ClassManagerImpl extends BshClassManager (Code) | |
Manage all classloading in BeanShell.
Allows classpath extension and class file reloading.
This class holds the implementation of the BshClassManager so that it
can be separated from the core package.
This class currently relies on 1.2 for BshClassLoader and weak references.
Is there a workaround for weak refs? If so we could make this work
with 1.1 by supplying our own classloader code...
See "http://www.beanshell.org/manual/classloading.html" for details
on the bsh classloader architecture.
Bsh has a multi-tiered class loading architecture. No class loader is
created unless/until a class is generated, the classpath is modified,
or a class is reloaded.
Note: we may need some synchronization in here
Note on jdk1.2 dependency:
We are forced to use weak references here to accomodate all of the
fleeting namespace listeners. (NameSpaces must be informed if the class
space changes so that they can un-cache names). I had the interesting
thought that a way around this would be to implement BeanShell's own
garbage collector... Then I came to my senses and said - screw it,
class re-loading will require 1.2.
---------------------
Classloading precedence:
in-script evaluated class (scripted class)
in-script added / modified classpath
optionally, external classloader
optionally, thread context classloader
plain Class.forName()
source class (.java file in classpath)
|
| ClassManagerImpl | | public ClassManagerImpl()(Code) | | Used by BshClassManager singleton constructor
|
| addListener | | public void addListener(Listener l)(Code) | | |
| classLoaderChanged | | protected void classLoaderChanged()(Code) | | Clear global class cache and notify namespaces to clear their
class caches.
The listener list is implemented with weak references so that we
will not keep every namespace in existence forever.
|
| defineClass | | public Class defineClass(String name, byte[] code)(Code) | | Get the BeanShell classloader.
public ClassLoader getClassLoader() {
}
|
| doSuperImport | | public void doSuperImport() throws UtilEvalError(Code) | | Support for "import *;"
Hide details in here as opposed to NameSpace.
|
| getClassNameByUnqName | | public String getClassNameByUnqName(String name) throws ClassPathException(Code) | | Return the name or null if none is found,
Throw an ClassPathException containing detail if name is ambigous.
|
| getResource | | public URL getResource(String path)(Code) | | Get a resource URL using the BeanShell classpath
Parameters:
path - should be an absolute path |
| getResourceAsStream | | public InputStream getResourceAsStream(String path)(Code) | | Get a resource stream using the BeanShell classpath
Parameters:
path - should be an absolute path |
| hasSuperImport | | protected boolean hasSuperImport()(Code) | | |
| reloadAllClasses | | public void reloadAllClasses() throws ClassPathException(Code) | | Overlay the entire path with a new class loader.
Set the base path to the user path + base path.
No point in including the boot class path (can't reload thos).
|
| reloadClasses | | public void reloadClasses(String[] classNames) throws ClassPathException(Code) | | Reloading classes means creating a new classloader and using it
whenever we are asked for classes in the appropriate space.
For this we use a DiscreteFilesClassLoader
|
| reloadPackage | | public void reloadPackage(String pack) throws ClassPathException(Code) | | Reload all classes in the specified package: e.g. "com.sun.tools"
The special package name "" can be used to refer
to unpackaged classes.
|
| removeListener | | public void removeListener(Listener l)(Code) | | |
| reset | | public void reset()(Code) | | Clear all classloading behavior and class caches and reset to
initial state.
|
| setClassPath | | public void setClassPath(URL[] cp)(Code) | | Set a new base classpath and create a new base classloader.
This means all types change.
|
|
|
|