bsh.classpath

Class ClassManagerImpl


public class ClassManagerImpl
extends BshClassManager

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)

Nested Class Summary

Nested classes/interfaces inherited from class bsh.BshClassManager

BshClassManager.Listener

Field Summary

Fields inherited from class bsh.BshClassManager

absoluteClassCache, absoluteNonClasses, definingClasses, definingClassesBaseNames, externalClassLoader, resolvedObjectMethods, resolvedStaticMethods

Constructor Summary

ClassManagerImpl()
Used by BshClassManager singleton constructor

Method Summary

void
addClassPath(URL path)
void
addListener(BshClassManager.Listener l)
Class
classForName(String name)
protected void
classLoaderChanged()
Clear global class cache and notify namespaces to clear their class caches.
Class
defineClass(String name, byte[] code)
Get the BeanShell classloader.
void
doSuperImport()
Support for "import *;" Hide details in here as opposed to NameSpace.
void
dump(PrintWriter i)
ClassLoader
getBaseLoader()
String
getClassNameByUnqName(String name)
Return the name or null if none is found, Throw an ClassPathException containing detail if name is ambigous.
BshClassPath
getClassPath()
Get the full blown classpath.
URL
getResource(String path)
Get a resource URL using the BeanShell classpath
InputStream
getResourceAsStream(String path)
Get a resource stream using the BeanShell classpath
protected boolean
hasSuperImport()
A "super import" ("import *") operation has been performed.
void
reloadAllClasses()
Overlay the entire path with a new class loader.
void
reloadClasses(String[] classNames)
Reloading classes means creating a new classloader and using it whenever we are asked for classes in the appropriate space.
void
reloadPackage(String pack)
Reload all classes in the specified package: e.g.
void
removeListener(BshClassManager.Listener l)
void
reset()
Clear all classloading behavior and class caches and reset to initial state.
void
setClassPath(URL[] cp)
Set a new base classpath and create a new base classloader.

Methods inherited from class bsh.BshClassManager

addClassPath, addListener, cacheClassInfo, cacheResolvedMethod, classExists, classForName, classLoaderChanged, clearCaches, cmUnavailable, createClassManager, defineClass, definingClass, doSuperImport, doneDefiningClass, dump, getClassBeingDefined, getClassNameByUnqName, getResolvedMethod, getResource, getResourceAsStream, hasSuperImport, isClassBeingDefined, loadSourceClass, noClassDefFound, plainClassForName, reloadAllClasses, reloadClasses, reloadPackage, removeListener, reset, setClassLoader, setClassPath

Constructor Details

ClassManagerImpl

public ClassManagerImpl()
Used by BshClassManager singleton constructor

Method Details

addClassPath

public void addClassPath(URL path)
            throws IOException
Overrides:
addClassPath in interface BshClassManager

addListener

public void addListener(BshClassManager.Listener l)
Overrides:
addListener in interface BshClassManager

classForName

public Class classForName(String name)
Overrides:
classForName in interface BshClassManager
Returns:
the class or null

classLoaderChanged

protected void classLoaderChanged()
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.
Overrides:
classLoaderChanged in interface BshClassManager

defineClass

public Class defineClass(String name,
                         byte[] code)
Get the BeanShell classloader. public ClassLoader getClassLoader() { }
Overrides:
defineClass in interface BshClassManager

doSuperImport

public void doSuperImport()
            throws UtilEvalError
Support for "import *;" Hide details in here as opposed to NameSpace.
Overrides:
doSuperImport in interface BshClassManager

dump

public void dump(PrintWriter i)
Overrides:
dump in interface BshClassManager

getBaseLoader

public ClassLoader getBaseLoader()

getClassNameByUnqName

public String getClassNameByUnqName(String name)
            throws ClassPathException
Return the name or null if none is found, Throw an ClassPathException containing detail if name is ambigous.
Overrides:
getClassNameByUnqName in interface BshClassManager

getClassPath

public BshClassPath getClassPath()
            throws ClassPathException
Get the full blown classpath.

getResource

public URL getResource(String path)
Get a resource URL using the BeanShell classpath
Overrides:
getResource in interface BshClassManager
Parameters:
path - should be an absolute path

getResourceAsStream

public InputStream getResourceAsStream(String path)
Get a resource stream using the BeanShell classpath
Overrides:
getResourceAsStream in interface BshClassManager
Parameters:
path - should be an absolute path

hasSuperImport

protected boolean hasSuperImport()
A "super import" ("import *") operation has been performed.
Overrides:
hasSuperImport in interface BshClassManager

reloadAllClasses

public void reloadAllClasses()
            throws ClassPathException
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).
Overrides:
reloadAllClasses in interface BshClassManager

reloadClasses

public void reloadClasses(String[] classNames)
            throws ClassPathException
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
Overrides:
reloadClasses in interface BshClassManager

reloadPackage

public void reloadPackage(String pack)
            throws ClassPathException
Reload all classes in the specified package: e.g. "com.sun.tools" The special package name "" can be used to refer to unpackaged classes.
Overrides:
reloadPackage in interface BshClassManager

removeListener

public void removeListener(BshClassManager.Listener l)
Overrides:
removeListener in interface BshClassManager

reset

public void reset()
Clear all classloading behavior and class caches and reset to initial state.
Overrides:
reset in interface BshClassManager

setClassPath

public void setClassPath(URL[] cp)
Set a new base classpath and create a new base classloader. This means all types change.
Overrides:
setClassPath in interface BshClassManager

B) 2000-2005 pat@pat.net :-)