LoaderRepository.java |
/* * JBoss, the OpenSource J2EE webOS * * Distributable under LGPL license. * See terms of license at gnu.org. */ package org.jboss.mx.loading; import EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap; import org.jboss.logging.Logger; import org.jboss.mx.server.ServerConstants; import org.jboss.util.loading.Translator; import javax.management.loading.ClassLoaderRepository; import java.net.URL; import java.util.HashMap; import java.util.List; import java.util.Vector; /** * Abstract base class of all loader repository implementations * * @see org.jboss.mx.loading.BasicLoaderRepository * * @author <a href="mailto:juha@jboss.org">Juha Lindfors</a>. * @version $Revision: 1.22 $ */ public abstract class LoaderRepository implements ServerConstants, ClassLoaderRepository { // Attributes ---------------------------------------------------- protected static Vector loaders = new Vector(); protected static LoaderRepository instance = null; protected Translator translator = null; /** The loaded classes cache, HashMap<String, Class>. * Access synchronized via this.classes monitor. */ private ConcurrentReaderHashMap classes = new ConcurrentReaderHashMap(); /** * Native signature to class map */ private static HashMap nativeClassBySignature; // Static -------------------------------------------------------- private static final Logger log = Logger.getLogger(LoaderRepository.class); /** * Construct the native class map */ static { nativeClassBySignature = new HashMap(); nativeClassBySignature.put("boolean", boolean.class); nativeClassBySignature.put("byte", byte.class); nativeClassBySignature.put("char", char.class); nativeClassBySignature.put("double", double.class); nativeClassBySignature.put("float", float.class); nativeClassBySignature.put("int", int.class); nativeClassBySignature.put("long", long.class); nativeClassBySignature.put("short", short.class); nativeClassBySignature.put("void", void.class); nativeClassBySignature.put("boolean[]", boolean[].class); nativeClassBySignature.put("byte[]", byte[].class); nativeClassBySignature.put("char[]", char[].class); nativeClassBySignature.put("double[]", double[].class); nativeClassBySignature.put("float[]", float[].class); nativeClassBySignature.put("int[]", int[].class); nativeClassBySignature.put("long[]", long[].class); nativeClassBySignature.put("short[]", short[].class); } // Public -------------------------------------------------------- public Vector getLoaders() { return loaders; } public URL[] getURLs() { return null; } public Class getCachedClass(String classname) { return (Class)classes.get(classname); } public Translator getTranslator() { return translator; } public void setTranslator(Translator t) { translator = t; } /** * Compare two loader repository, by default we do no special ordering * * @param lr the loader repository * @return -1, 0, 1 depending upon the order */ public int compare(LoaderRepository lr) { if (lr == this) return 0; else return -lr.reverseCompare(this); } // BEGIN ClassLoaderRepository ************************************************************************************** /** * Loads a class from the repository. This method attempts to load the class * using all the classloader registered to the repository. * * @param className the class to load * @return the found class * @exception ClassNotFoundException when there is no such class */ public abstract Class loadClass(String className) throws ClassNotFoundException; /** * Loads a class from the repository, excluding the given * classloader. * * @param loader the classloader to exclude * @param className the class to load * @return the found class * @exception ClassNotFoundException when there is no such class */ public abstract Class loadClassWithout(ClassLoader loader, String className) throws ClassNotFoundException; /** * Loads a class from the repository, using the classloaders that were * registered before the given classloader. * * @param stop consult all the classloaders registered before this one * in an attempt to load a class * @param className name of the class to load * * @return loaded class instance * * @throws ClassNotFoundException if none of the consulted classloaders were * able to load the requested class */ public abstract Class loadClassBefore(ClassLoader stop, String className) throws ClassNotFoundException; // END ClassLoaderRepository **************************************************************************************** /** Create RepositoryClassLoader and optionally add it to the repository * @param url the URL to use for class loading * @param addToRepository a flag indicating if the CL should be added to * the repository * @return the UCL instance * @throws Exception */ public abstract RepositoryClassLoader newClassLoader(final URL url, boolean addToRepository) throws Exception; /** Create RepositoryClassLoader and optionally add it to the repository * @param url the URL to use for class loading * @param origURL an orignal URL to use as the URL for the CL CodeSource. * This is useful when the url is a local copy that is difficult to use for * security policy writing. * @param addToRepository a flag indicating if the CL should be added to * the repository * @return the CL instance * @throws Exception */ public abstract RepositoryClassLoader newClassLoader(final URL url, final URL origURL, boolean addToRepository) throws Exception; /** Load the given class from the repository * @param name * @param resolve * @param cl * @return * @throws ClassNotFoundException */ public abstract Class loadClass(String name, boolean resolve, ClassLoader cl) throws ClassNotFoundException; /** Find a resource URL for the given name * * @param name the resource name * @param cl the requesting class loader * @return The resource URL if found, null otherwise */ public abstract URL getResource(String name, ClassLoader cl); /** Find all resource URLs for the given name. Since this typically * entails an exhuastive search of the repository it can be a relatively * slow operation. * * @param name the resource name * @param cl the requesting class loader * @param urls a list into which the located resource URLs will be placed */ public abstract void getResources(String name, ClassLoader cl, List urls); /** Add a class loader to the repository */ public abstract void addClassLoader(ClassLoader cl); /** Update the set of URLs known to be associated with a previously added * class loader. * * @param cl * @param url */ public abstract boolean addClassLoaderURL(ClassLoader cl, URL url); /** Remove a cladd loader from the repository. * @param cl */ public abstract void removeClassLoader(ClassLoader cl); /** * Return the class of a java native type * @return the class, or null if className is not a native class name */ public static final Class getNativeClassForName(String className) { // Check for native classes return (Class)nativeClassBySignature.get(className); } /** * Allow subclasses to override the ordering * * @param lr the loader repository * @return -1, 0, 1 depending upon the order */ protected int reverseCompare(LoaderRepository lr) { return 0; } /** * Add a class to the the cache */ void cacheLoadedClass(String name, Class cls, ClassLoader cl) { synchronized( classes ) { // Update the global cache classes.put(name, cls); if( log.isTraceEnabled() ) { log.trace("cacheLoadedClass, classname: "+name+", class: "+cls +", cl: "+cl); } /** * TODO: Adding this implementation is a hack for jmx 1.2 checkin. * Had to add this because need getCachedClass() to work. * However, this method does not add loaded classes to collection * to be unloaded when called to remove classloader. * Hopefully this will be a short term workaround. * Contact telrod@e2technologies.net if you have questions. -TME */ } } void clear() { classes.clear(); } }
LoaderRepository.java |