Package org.gjt.sp.jedit.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)

    • Constructor Detail

      • ClassManagerImpl

        public ClassManagerImpl()
        Used by BshClassManager singleton constructor

    • Method Detail

      • classForName

        public java.lang.Class classForName​(java.lang.String name)
        Description copied from class: BshClassManager
        Load the specified class by name, taking into account added classpath and reloaded classes, etc. Note: Again, this is just a trivial implementation. See bsh.classpath.ClassManagerImpl for the fully functional class management package.
        Overrides:
        classForName in class BshClassManager
        Returns:
        the class or null

      • getResource

        public java.net.URL getResource​(java.lang.String path)
        Get a resource URL using the BeanShell classpath
        Overrides:
        getResource in class BshClassManager
        Parameters:
        path - should be an absolute path

      • getResourceAsStream

        public java.io.InputStream getResourceAsStream​(java.lang.String path)
        Get a resource stream using the BeanShell classpath
        Overrides:
        getResourceAsStream in class BshClassManager
        Parameters:
        path - should be an absolute path

      • addClassPath

        public void addClassPath​(java.net.URL path)
                  throws java.io.IOException
        Overrides:
        addClassPath in class BshClassManager
        Throws:
        java.io.IOException

      • reset

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

      • setClassPath

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

      • reloadClasses

        public void reloadClasses​(java.lang.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 class BshClassManager
        Throws:
        ClassPathException

      • reloadPackage

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

      • getBaseLoader

        public java.lang.ClassLoader getBaseLoader()

      • defineClass

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

      • 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 class BshClassManager

      • dump

        public void dump​(java.io.PrintWriter i)
        Overrides:
        dump in class BshClassManager