ClassLoader.java revision 6338
0N/A * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved. 0N/A * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 0N/A * This code is free software; you can redistribute it and/or modify it 0N/A * under the terms of the GNU General Public License version 2 only, as 0N/A * published by the Free Software Foundation. Oracle designates this 0N/A * particular file as subject to the "Classpath" exception as provided 0N/A * by Oracle in the LICENSE file that accompanied this code. 0N/A * This code is distributed in the hope that it will be useful, but WITHOUT 0N/A * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 0N/A * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 0N/A * version 2 for more details (a copy is included in the LICENSE file that 0N/A * accompanied this code). 0N/A * You should have received a copy of the GNU General Public License version 2362N/A * 2 along with this work; if not, write to the Free Software Foundation, 2362N/A * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 0N/A * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 0N/A * or visit www.oracle.com if you need additional information or have any 0N/A * A class loader is an object that is responsible for loading classes. The 0N/A * class <tt>ClassLoader</tt> is an abstract class. Given the <a 0N/A * href="#name">binary name</a> of a class, a class loader should attempt to 3203N/A * locate or generate data that constitutes a definition for the class. A 0N/A * typical strategy is to transform the name into a file name and then read a 0N/A * "class file" of that name from a file system. 0N/A * <p> Every {@link Class <tt>Class</tt>} object contains a {@link 0N/A * Class#getClassLoader() reference} to the <tt>ClassLoader</tt> that defined 0N/A * <p> <tt>Class</tt> objects for array classes are not created by class 0N/A * loaders, but are created automatically as required by the Java runtime. 0N/A * The class loader for an array class, as returned by {@link 0N/A * Class#getClassLoader()} is the same as the class loader for its element 0N/A * type; if the element type is a primitive type, then the array class has no 0N/A * <p> Applications implement subclasses of <tt>ClassLoader</tt> in order to 0N/A * extend the manner in which the Java virtual machine dynamically loads 0N/A * <p> Class loaders may typically be used by security managers to indicate 0N/A * <p> The <tt>ClassLoader</tt> class uses a delegation model to search for 0N/A * classes and resources. Each instance of <tt>ClassLoader</tt> has an 0N/A * associated parent class loader. When requested to find a class or 0N/A * resource, a <tt>ClassLoader</tt> instance will delegate the search for the 0N/A * class or resource to its parent class loader before attempting to find the 0N/A * class or resource itself. The virtual machine's built-in class loader, 0N/A * called the "bootstrap class loader", does not itself have a parent but may 0N/A * serve as the parent of a <tt>ClassLoader</tt> instance. 0N/A * <p> Class loaders that support concurrent loading of classes are known as 0N/A * <em>parallel capable</em> class loaders and are required to register 0N/A * themselves at their class initialization time by invoking the 0N/A * #registerAsParallelCapable <tt>ClassLoader.registerAsParallelCapable</tt>} 0N/A * method. Note that the <tt>ClassLoader</tt> class is registered as parallel 0N/A * capable by default. However, its subclasses still need to register themselves 0N/A * if they are parallel capable. <br> 0N/A * In environments in which the delegation model is not strictly 0N/A * hierarchical, class loaders need to be parallel capable, otherwise class 0N/A * loading can lead to deadlocks because the loader lock is held for the 0N/A * duration of the class loading process (see {@link #loadClass 0N/A * <tt>loadClass</tt>} methods). 0N/A * <p> Normally, the Java virtual machine loads classes from the local file 0N/A * system in a platform-dependent manner. For example, on UNIX systems, the 0N/A * virtual machine loads classes from the directory defined by the 0N/A * <tt>CLASSPATH</tt> environment variable. 0N/A * <p> However, some classes may not originate from a file; they may originate 1771N/A * from other sources, such as the network, or they could be constructed by an 0N/A * application. The method {@link #defineClass(String, byte[], int, int) 0N/A * <tt>defineClass</tt>} converts an array of bytes into an instance of class 0N/A * <tt>Class</tt>. Instances of this newly defined class can be created using 0N/A * {@link Class#newInstance <tt>Class.newInstance</tt>}. 0N/A * <p> The methods and constructors of objects created by a class loader may 0N/A * reference other classes. To determine the class(es) referred to, the Java 0N/A * virtual machine invokes the {@link #loadClass <tt>loadClass</tt>} method of 0N/A * the class loader that originally created the class. 0N/A * <p> For example, an application could create a network class loader to 0N/A * download class files from a server. Sample code might look like: 0N/A * ClassLoader loader = new NetworkClassLoader(host, port); 0N/A * Object main = loader.loadClass("Main", true).newInstance(); 0N/A * . . . 0N/A * </pre></blockquote> 0N/A * <p> The network class loader subclass must define the methods {@link 0N/A * #findClass <tt>findClass</tt>} and <tt>loadClassData</tt> to load a class 0N/A * from the network. Once it has downloaded the bytes that make up the class, 0N/A * it should use the method {@link #defineClass <tt>defineClass</tt>} to 0N/A * create a class instance. A sample implementation is: 0N/A * class NetworkClassLoader extends ClassLoader { 0N/A * public Class findClass(String name) { 0N/A * byte[] b = loadClassData(name); 0N/A * return defineClass(name, b, 0, b.length); 0N/A * private byte[] loadClassData(String name) { 0N/A * // load the class data from the connection 0N/A * . . . 0N/A * </pre></blockquote> 0N/A * <h4> <a name="name">Binary names</a> </h4> 0N/A * <p> Any class name provided as a {@link String} parameter to methods in 0N/A * <tt>ClassLoader</tt> must be a binary name as defined by 0N/A * <cite>The Java™ Language Specification</cite>. * <p> Examples of valid class names include: * "javax.swing.JSpinner$DefaultEditor" * "java.security.KeyStore$Builder$FileBuilder$1" * "java.net.URLClassLoader$3$1" * @see #resolveClass(Class) // The parent class loader for delegation // Note: VM hardcoded the offset of this field, thus all new fields // must be added *after* it. * Encapsulates the set of parallel capable loader types. // the set of parallel capable loader types * Registers the given class loader type as parallel capabale. * Returns {@code true} is successfully registered; {@code false} if * loader's super class is not registered. // register the class loader as parallel capable // if and only if all of its super classes are. // Note: given current classloading sequence, if // the immediate super class is parallel capable, // all the super classes higher up must be too. * Returns {@code true} if the given class loader type is * registered as parallel capable. // Maps class name to the corresponding lock object when the current // class loader is parallel capable. // Note: VM also uses this field to decide if the current class loader // is parallel capable and the appropriate lock object for class loading. // Hashtable that maps packages to certs // Shared among all packages with unsigned classes // The classes loaded by this class loader. The only purpose of this table // is to keep the classes from being GC'ed until the loader is GC'ed. // The "default" domain. Set as the default ProtectionDomain on newly // The initiating protection domains for all classes loaded by this loader // Invoked by the VM to record every loaded class with this loader. // The packages defined in this class loader. Each package name is mapped // to its corresponding Package object. // no finer-grained lock; lock on the classloader instance * Creates a new class loader using the specified parent class loader for * <p> If there is a security manager, its {@link * SecurityManager#checkCreateClassLoader() * <tt>checkCreateClassLoader</tt>} method is invoked. This may result in * a security exception. </p> * The parent class loader * @throws SecurityException * If a security manager exists and its * <tt>checkCreateClassLoader</tt> method doesn't allow creation * Creates a new class loader using the <tt>ClassLoader</tt> returned by * the method {@link #getSystemClassLoader() * <tt>getSystemClassLoader()</tt>} as the parent class loader. * <p> If there is a security manager, its {@link * SecurityManager#checkCreateClassLoader() * <tt>checkCreateClassLoader</tt>} method is invoked. This may result in * a security exception. </p> * @throws SecurityException * If a security manager exists and its * <tt>checkCreateClassLoader</tt> method doesn't allow creation * Loads the class with the specified <a href="#name">binary name</a>. * This method searches for classes in the same manner as the {@link * #loadClass(String, boolean)} method. It is invoked by the Java virtual * machine to resolve class references. Invoking this method is equivalent * to invoking {@link #loadClass(String, boolean) <tt>loadClass(name, * The <a href="#name">binary name</a> of the class * @return The resulting <tt>Class</tt> object * @throws ClassNotFoundException * If the class was not found * Loads the class with the specified <a href="#name">binary name</a>. The * default implementation of this method searches for classes in the * <li><p> Invoke {@link #findLoadedClass(String)} to check if the class * has already been loaded. </p></li> * <li><p> Invoke the {@link #loadClass(String) <tt>loadClass</tt>} method * on the parent class loader. If the parent is <tt>null</tt> the class * loader built-in to the virtual machine is used, instead. </p></li> * <li><p> Invoke the {@link #findClass(String)} method to find the * <p> If the class was found using the above steps, and the * <tt>resolve</tt> flag is true, this method will then invoke the {@link * #resolveClass(Class)} method on the resulting <tt>Class</tt> object. * <p> Subclasses of <tt>ClassLoader</tt> are encouraged to override {@link * #findClass(String)}, rather than this method. </p> * <p> Unless overridden, this method synchronizes on the result of * {@link #getClassLoadingLock <tt>getClassLoadingLock</tt>} method * during the entire class loading process. * The <a href="#name">binary name</a> of the class * If <tt>true</tt> then resolve the class * @return The resulting <tt>Class</tt> object * @throws ClassNotFoundException * If the class could not be found // First, check if the class has already been loaded // ClassNotFoundException thrown if class not found // from the non-null parent class loader // If still not found, then invoke findClass in order // this is the defining class loader; record the stats * Returns the lock object for class loading operations. * For backward compatibility, the default implementation of this method * behaves as follows. If this ClassLoader object is registered as * parallel capable, the method returns a dedicated object associated * with the specified class name. Otherwise, the method returns this * ClassLoader object. </p> * The name of the to-be-loaded class * @return the lock for class loading operations * @throws NullPointerException * If registered as parallel capable and <tt>className</tt> is null * @see #loadClass(String, boolean) // This method is invoked by the virtual machine to load a class. // For backward compatibility, explicitly lock on 'this' when // the current class loader is not parallel capable. // Invoked by the VM after loading class with this loader. * Finds the class with the specified <a href="#name">binary name</a>. * This method should be overridden by class loader implementations that * follow the delegation model for loading classes, and will be invoked by * the {@link #loadClass <tt>loadClass</tt>} method after checking the * parent class loader for the requested class. The default implementation * throws a <tt>ClassNotFoundException</tt>. </p> * The <a href="#name">binary name</a> of the class * @return The resulting <tt>Class</tt> object * @throws ClassNotFoundException * If the class could not be found * Converts an array of bytes into an instance of class <tt>Class</tt>. * Before the <tt>Class</tt> can be used it must be resolved. This method * is deprecated in favor of the version that takes a <a * href="#name">binary name</a> as its first argument, and is more secure. * The bytes that make up the class data. The bytes in positions * <tt>off</tt> through <tt>off+len-1</tt> should have the format * of a valid class file as defined by * <cite>The Java™ Virtual Machine Specification</cite>. * The start offset in <tt>b</tt> of the class data * The length of the class data * @return The <tt>Class</tt> object that was created from the specified * @throws ClassFormatError * If the data did not contain a valid class * @throws IndexOutOfBoundsException * If either <tt>off</tt> or <tt>len</tt> is negative, or if * <tt>off+len</tt> is greater than <tt>b.length</tt>. * @throws SecurityException * If an attempt is made to add this class to a package that * contains classes that were signed by a different set of * certificates than this class, or if an attempt is made * to define a class in a package with a fully-qualified name * that starts with "{@code java.}". * @see #loadClass(String, boolean) * @see #resolveClass(Class) * @deprecated Replaced by {@link #defineClass(String, byte[], int, int) * defineClass(String, byte[], int, int)} * Converts an array of bytes into an instance of class <tt>Class</tt>. * Before the <tt>Class</tt> can be used it must be resolved. * <p> This method assigns a default {@link java.security.ProtectionDomain * <tt>ProtectionDomain</tt>} to the newly defined class. The * <tt>ProtectionDomain</tt> is effectively granted the same set of * permissions returned when {@link * java.security.Policy#getPermissions(java.security.CodeSource) * <tt>Policy.getPolicy().getPermissions(new CodeSource(null, null))</tt>} * is invoked. The default domain is created on the first invocation of * {@link #defineClass(String, byte[], int, int) <tt>defineClass</tt>}, * and re-used on subsequent invocations. * <p> To assign a specific <tt>ProtectionDomain</tt> to the class, use * the {@link #defineClass(String, byte[], int, int, * java.security.ProtectionDomain) <tt>defineClass</tt>} method that takes a * <tt>ProtectionDomain</tt> as one of its arguments. </p> * The expected <a href="#name">binary name</a> of the class, or * <tt>null</tt> if not known * The bytes that make up the class data. The bytes in positions * <tt>off</tt> through <tt>off+len-1</tt> should have the format * of a valid class file as defined by * <cite>The Java™ Virtual Machine Specification</cite>. * The start offset in <tt>b</tt> of the class data * The length of the class data * @return The <tt>Class</tt> object that was created from the specified * @throws ClassFormatError * If the data did not contain a valid class * @throws IndexOutOfBoundsException * If either <tt>off</tt> or <tt>len</tt> is negative, or if * <tt>off+len</tt> is greater than <tt>b.length</tt>. * @throws SecurityException * If an attempt is made to add this class to a package that * contains classes that were signed by a different set of * certificates than this class (which is unsigned), or if * <tt>name</tt> begins with "<tt>java.</tt>". * @see #loadClass(String, boolean) * @see #resolveClass(Class) * @see java.security.CodeSource * @see java.security.SecureClassLoader /* Determine protection domain, and check that: - not define java.* class, - signer of this class matches signers for the rest of the classes in (
"Prohibited package name: " +
// Class format error - try to transform the bytecode and // define the class again // Transform byte code using transformer // If ClassFormatError occurs, try next transformer // Rethrow original ClassFormatError if unable to transform // bytecode to well-formed * Converts an array of bytes into an instance of class <tt>Class</tt>, * with an optional <tt>ProtectionDomain</tt>. If the domain is * <tt>null</tt>, then a default domain will be assigned to the class as * specified in the documentation for {@link #defineClass(String, byte[], * int, int)}. Before the class can be used it must be resolved. * <p> The first class defined in a package determines the exact set of * certificates that all subsequent classes defined in that package must * contain. The set of certificates for a class is obtained from the * {@link java.security.CodeSource <tt>CodeSource</tt>} within the * <tt>ProtectionDomain</tt> of the class. Any classes added to that * package must contain the same set of certificates or a * <tt>SecurityException</tt> will be thrown. Note that if * <tt>name</tt> is <tt>null</tt>, this check is not performed. * You should always pass in the <a href="#name">binary name</a> of the * class you are defining as well as the bytes. This ensures that the * class you are defining is indeed the class you think it is. * <p> The specified <tt>name</tt> cannot begin with "<tt>java.</tt>", since * all classes in the "<tt>java.*</tt> packages can only be defined by the * bootstrap class loader. If <tt>name</tt> is not <tt>null</tt>, it * must be equal to the <a href="#name">binary name</a> of the class * specified by the byte array "<tt>b</tt>", otherwise a {@link * <tt>NoClassDefFoundError</tt>} will be thrown. </p> * The expected <a href="#name">binary name</a> of the class, or * <tt>null</tt> if not known * The bytes that make up the class data. The bytes in positions * <tt>off</tt> through <tt>off+len-1</tt> should have the format * of a valid class file as defined by * <cite>The Java™ Virtual Machine Specification</cite>. * The start offset in <tt>b</tt> of the class data * The length of the class data * @param protectionDomain * The ProtectionDomain of the class * @return The <tt>Class</tt> object created from the data, * and optional <tt>ProtectionDomain</tt>. * @throws ClassFormatError * If the data did not contain a valid class * @throws NoClassDefFoundError * If <tt>name</tt> is not equal to the <a href="#name">binary * name</a> of the class specified by <tt>b</tt> * @throws IndexOutOfBoundsException * If either <tt>off</tt> or <tt>len</tt> is negative, or if * <tt>off+len</tt> is greater than <tt>b.length</tt>. * @throws SecurityException * If an attempt is made to add this class to a package that * contains classes that were signed by a different set of * certificates than this class, or if <tt>name</tt> begins with * Converts a {@link java.nio.ByteBuffer <tt>ByteBuffer</tt>} * into an instance of class <tt>Class</tt>, * with an optional <tt>ProtectionDomain</tt>. If the domain is * <tt>null</tt>, then a default domain will be assigned to the class as * specified in the documentation for {@link #defineClass(String, byte[], * int, int)}. Before the class can be used it must be resolved. * <p>The rules about the first class defined in a package determining the * set of certificates for the package, and the restrictions on class names * are identical to those specified in the documentation for {@link * #defineClass(String, byte[], int, int, ProtectionDomain)}. * <p> An invocation of this method of the form * <i>cl</i><tt>.defineClass(</tt><i>name</i><tt>,</tt> * <i>bBuffer</i><tt>,</tt> <i>pd</i><tt>)</tt> yields exactly the same * result as the statements * byte[] temp = new byte[</tt><i>bBuffer</i><tt>.{@link * java.nio.ByteBuffer#remaining remaining}()];<br> * </tt><i>bBuffer</i><tt>.{@link java.nio.ByteBuffer#get(byte[]) * return {@link #defineClass(String, byte[], int, int, ProtectionDomain) * </tt><i>cl</i><tt>.defineClass}(</tt><i>name</i><tt>, temp, 0, * temp.length, </tt><i>pd</i><tt>);<br> * The expected <a href="#name">binary name</a>. of the class, or * <tt>null</tt> if not known * The bytes that make up the class data. The bytes from positions * <tt>b.position()</tt> through <tt>b.position() + b.limit() -1 * </tt> should have the format of a valid class file as defined by * <cite>The Java™ Virtual Machine Specification</cite>. * @param protectionDomain * The ProtectionDomain of the class, or <tt>null</tt>. * @return The <tt>Class</tt> object created from the data, * and optional <tt>ProtectionDomain</tt>. * @throws ClassFormatError * If the data did not contain a valid class. * @throws NoClassDefFoundError * If <tt>name</tt> is not equal to the <a href="#name">binary * name</a> of the class specified by <tt>b</tt> * @throws SecurityException * If an attempt is made to add this class to a package that * contains classes that were signed by a different set of * certificates than this class, or if <tt>name</tt> begins with * @see #defineClass(String, byte[], int, int, ProtectionDomain) // Use byte[] if not a direct ByteBufer: // no array, or read-only array byte[]
tb =
new byte[
len];
b.
get(
tb);
// get bytes out of byte buffer. byte[]
tb =
new byte[
len];
b.
get(
tb);
// get bytes out of byte buffer. // true if the name is null or has the potential to be a valid binary name "\"'s signer information does not match signer information of other classes in the same package");
* check to make sure the certs for the new class (certs) are the same as * the certs for the first class inserted in the package (pcerts) // certs can be null, indicating no certs. // the length must be the same at this point // go through and make sure all the certs in one array // are in the other and vice-versa. if (!
match)
return false;
// now do the same for pcerts if (!
match)
return false;
* Links the specified class. This (misleadingly named) method may be * used by a class loader to link a class. If the class <tt>c</tt> has * already been linked, then this method simply returns. Otherwise, the * class is linked as described in the "Execution" chapter of * <cite>The Java™ Language Specification</cite>. * @throws NullPointerException * If <tt>c</tt> is <tt>null</tt>. * @see #defineClass(String, byte[], int, int) * Finds a class with the specified <a href="#name">binary name</a>, * loading it if necessary. * <p> This method loads the class through the system class loader (see * {@link #getSystemClassLoader()}). The <tt>Class</tt> object returned * might have more than one <tt>ClassLoader</tt> associated with it. * Subclasses of <tt>ClassLoader</tt> need not usually invoke this method, * because most class loaders need to override just {@link * #findClass(String)}. </p> * The <a href="#name">binary name</a> of the class * @return The <tt>Class</tt> object for the specified <tt>name</tt> * @throws ClassNotFoundException * If the class could not be found * @see #ClassLoader(ClassLoader) * Returns a class loaded by the bootstrap class loader; * or return null if not found. // return null if not found * Returns the class with the given <a href="#name">binary name</a> if this * loader has been recorded by the Java virtual machine as an initiating * loader of a class with that <a href="#name">binary name</a>. Otherwise * <tt>null</tt> is returned. </p> * The <a href="#name">binary name</a> of the class * @return The <tt>Class</tt> object, or <tt>null</tt> if the class has * Sets the signers of a class. This should be invoked after defining a * The <tt>Class</tt> object * The signers for the class * Finds the resource with the given name. A resource is some data * (images, audio, text, etc) that can be accessed by class code in a way * that is independent of the location of the code. * <p> The name of a resource is a '<tt>/</tt>'-separated path name that * identifies the resource. * <p> This method will first search the parent class loader for the * resource; if the parent is <tt>null</tt> the path of the class loader * built-in to the virtual machine is searched. That failing, this method * will invoke {@link #findResource(String)} to find the resource. </p> * @return A <tt>URL</tt> object for reading the resource, or * <tt>null</tt> if the resource could not be found or the invoker * doesn't have adequate privileges to get the resource. * Finds all the resources with the given name. A resource is some data * (images, audio, text, etc) that can be accessed by class code in a way * that is independent of the location of the code. * <p>The name of a resource is a <tt>/</tt>-separated path name that * identifies the resource. * <p> The search order is described in the documentation for {@link * #getResource(String)}. </p> * @return An enumeration of {@link java.net.URL <tt>URL</tt>} objects for * the resource. If no resources could be found, the enumeration * will be empty. Resources that the class loader doesn't have * access to will not be in the enumeration. * @see #findResources(String) * Finds the resource with the given name. Class loader implementations * should override this method to specify where to find resources. </p> * @return A <tt>URL</tt> object for reading the resource, or * <tt>null</tt> if the resource could not be found * Returns an enumeration of {@link java.net.URL <tt>URL</tt>} objects * representing all the resources with the given name. Class loader * implementations should override this method to specify where to load * @return An enumeration of {@link java.net.URL <tt>URL</tt>} objects for * Registers the caller as parallel capable.</p> * The registration succeeds if and only if all of the following * conditions are met: <br> * 1. no instance of the caller has been created</p> * 2. all of the super classes (except class Object) of the caller are * registered as parallel capable</p> * Note that once a class loader is registered as parallel capable, there * is no way to change it back. </p> * @return true if the caller is successfully registered as * parallel capable and false if otherwise. * Find a resource of the specified name from the search path used to load * classes. This method locates the resource through the system class * loader (see {@link #getSystemClassLoader()}). </p> * @return A {@link java.net.URL <tt>URL</tt>} object for reading the * resource, or <tt>null</tt> if the resource could not be found * Finds all resources of the specified name from the search path used to * load classes. The resources thus found are returned as an * {@link java.util.Enumeration <tt>Enumeration</tt>} of {@link * java.net.URL <tt>URL</tt>} objects. * <p> The search order is described in the documentation for {@link * #getSystemResource(String)}. </p> * @return An enumeration of resource {@link java.net.URL <tt>URL</tt>} * Find resources from the VM's built-in classloader. * Find resources from the VM's built-in classloader. // Returns the URLClassPath that is used for finding system resources. * Returns an input stream for reading the specified resource. * <p> The search order is described in the documentation for {@link * #getResource(String)}. </p> * @return An input stream for reading the resource, or <tt>null</tt> * if the resource could not be found * Open for reading, a resource of the specified name from the search path * used to load classes. This method locates the resource through the * system class loader (see {@link #getSystemClassLoader()}). </p> * @return An input stream for reading the resource, or <tt>null</tt> * if the resource could not be found * Returns the parent class loader for delegation. Some implementations may * use <tt>null</tt> to represent the bootstrap class loader. This method * will return <tt>null</tt> in such implementations if this class loader's * parent is the bootstrap class loader. * <p> If a security manager is present, and the invoker's class loader is * not <tt>null</tt> and is not an ancestor of this class loader, then this * method invokes the security manager's {@link * SecurityManager#checkPermission(java.security.Permission) * <tt>checkPermission</tt>} method with a {@link * RuntimePermission#RuntimePermission(String) * <tt>RuntimePermission("getClassLoader")</tt>} permission to verify * access to the parent class loader is permitted. If not, a * <tt>SecurityException</tt> will be thrown. </p> * @return The parent <tt>ClassLoader</tt> * @throws SecurityException * If a security manager exists and its <tt>checkPermission</tt> * method doesn't allow access to this class loader's parent class * Returns the system class loader for delegation. This is the default * delegation parent for new <tt>ClassLoader</tt> instances, and is * typically the class loader used to start the application. * <p> This method is first invoked early in the runtime's startup * sequence, at which point it creates the system class loader and sets it * as the context class loader of the invoking <tt>Thread</tt>. * <p> The default system class loader is an implementation-dependent * instance of this class. * <p> If the system property "<tt>java.system.class.loader</tt>" is defined * when this method is first invoked then the value of that property is * taken to be the name of a class that will be returned as the system * class loader. The class is loaded using the default system class loader * and must define a public constructor that takes a single parameter of * type <tt>ClassLoader</tt> which is used as the delegation parent. An * instance is then created using this constructor with the default system * class loader as the parameter. The resulting class loader is defined * to be the system class loader. * <p> If a security manager is present, and the invoker's class loader is * not <tt>null</tt> and the invoker's class loader is not the same as or * an ancestor of the system class loader, then this method invokes the * security manager's {@link * SecurityManager#checkPermission(java.security.Permission) * <tt>checkPermission</tt>} method with a {@link * RuntimePermission#RuntimePermission(String) * <tt>RuntimePermission("getClassLoader")</tt>} permission to verify * access to the system class loader. If not, a * <tt>SecurityException</tt> will be thrown. </p> * @return The system <tt>ClassLoader</tt> for delegation, or * @throws SecurityException * If a security manager exists and its <tt>checkPermission</tt> * method doesn't allow access to the system class loader. * @throws IllegalStateException * If invoked recursively during the construction of the class * loader specified by the "<tt>java.system.class.loader</tt>" * If the system property "<tt>java.system.class.loader</tt>" * is defined but the named class could not be loaded, the * provider class does not define the required constructor, or an * exception is thrown by that constructor when it is invoked. The * underlying cause of the error can be retrieved via the * {@link Throwable#getCause()} method. // Returns true if the specified class loader can be found in this class // loader's delegation chain. // Tests if class loader access requires "getClassLoader" permission // check. A class loader 'from' can access class loader 'to' if // class loader 'from' is same as class loader 'to' or an ancestor // of 'to'. The class loader in a system domain can access // Returns the class's class loader, or null if none. // This can be null if the VM is requesting it // Circumvent security check since this is package-private // caller can be null if the VM is requesting it // The class loader for the system // @GuardedBy("ClassLoader.class") // Set to true once the system class loader has been set // @GuardedBy("ClassLoader.class") private static boolean sclSet;
* Defines a package by name in this <tt>ClassLoader</tt>. This allows * class loaders to define the packages for their classes. Packages must * be created before the class is defined, and package names must be * unique within a class loader and cannot be redefined or changed once * The specification title * The specification version * The specification vendor * The implementation title * The implementation version * The implementation vendor * If not <tt>null</tt>, then this package is sealed with * respect to the given code source {@link java.net.URL * <tt>URL</tt>} object. Otherwise, the package is not sealed. * @return The newly defined <tt>Package</tt> object * @throws IllegalArgumentException * If package name duplicates an existing package either in this * class loader or one of its ancestors * Returns a <tt>Package</tt> that has been defined by this class loader * or any of its ancestors. </p> * @return The <tt>Package</tt> corresponding to the given name, or * <tt>null</tt> if not found * Returns all of the <tt>Packages</tt> defined by this class loader and * @return The array of <tt>Package</tt> objects defined by this // -- Native library access -- * Returns the absolute path name of a native library. The VM invokes this * method to locate the native libraries that belong to classes loaded with * this class loader. If this method returns <tt>null</tt>, the VM * searches the library along the path specified as the * "<tt>java.library.path</tt>" property. </p> * @return The absolute path of the native library * @see System#loadLibrary(String) * @see System#mapLibraryName(String) * The inner class NativeLibrary denotes a loaded native library instance. * Every classloader contains a vector of loaded native libraries in the * private field <tt>nativeLibraries</tt>. The native libraries loaded * into the system are entered into the <tt>systemNativeLibraries</tt> * <p> Every native library requires a particular version of JNI. This is * denoted by the private <tt>jniVersion</tt> field. This field is set by * the VM when it loads the library, and used by the VM to pass the correct * version of JNI to the native methods. </p> // opaque handle to native library, used in native code. // the version of JNI environment the native library requires. // the class from which the library is loaded, also indicates // the loader this native library belongs. // the canonicalized name of the native library. /* remove the native library name */ for (
int i =
0; i <
size; i++) {
/* unload the library. */ // Invoked in the VM to determine the context class in // All native library names we've loaded. // Native libraries belonging to system classes. // Native libraries associated with the class loader. // The paths searched for libraries // Count the separators in the path // allocate the array of paths - n :'s = n + 1 path elements // Fill the array with paths from the ldpath // Invoked in the java.lang.Runtime class to implement load and loadLibrary. "ClassLoader.findLibrary failed to return an absolute path: " +
libfilename);
for (
int i =
0; i <
size; i++) {
" already loaded in another classloader");
/* If the library is being loaded (must be by the same thread, * because Runtime.load and Runtime.loadLibrary are * synchronous). The reason is can occur is that the JNI_OnLoad * function can cause another loadLibrary invocation. * Thus we can use a static stack to hold the list of libraries * If there is a pending load operation for the library, we * immediately return success; otherwise, we raise for (
int i =
0; i < n; i++) {
" is being loaded in another classloader");
// Invoked in the VM class linking code. for (
int i =
0; i <
size; i++) {
// -- Assertion management -- // The default toggle for assertion checking. // @GuardedBy("assertionLock") // Maps String packageName to Boolean package default assertion status Note // that the default package is placed under a null map key. If this field // is null then we are delegating assertion status queries to the VM, i.e., // none of this ClassLoader's assertion status modification methods have // @GuardedBy("assertionLock") // Maps String fullyQualifiedClassName to Boolean assertionStatus If this // field is null then we are delegating assertion status queries to the VM, // i.e., none of this ClassLoader's assertion status modification methods // @GuardedBy("assertionLock") * Sets the default assertion status for this class loader. This setting * determines whether classes loaded by this class loader and initialized * in the future will have assertions enabled or disabled by default. * This setting may be overridden on a per-package or per-class basis by * invoking {@link #setPackageAssertionStatus(String, boolean)} or {@link * #setClassAssertionStatus(String, boolean)}. </p> * <tt>true</tt> if classes loaded by this class loader will * henceforth have assertions enabled by default, <tt>false</tt> * if they will have assertions disabled by default. * Sets the package default assertion status for the named package. The * package default assertion status determines the assertion status for * classes initialized in the future that belong to the named package or * any of its "subpackages". * <p> A subpackage of a package named p is any package whose name begins * with "<tt>p.</tt>". For example, <tt>javax.swing.text</tt> is a * subpackage of <tt>javax.swing</tt>, and both <tt>java.util</tt> and * <tt>java.lang.reflect</tt> are subpackages of <tt>java</tt>. * <p> In the event that multiple package defaults apply to a given class, * the package default pertaining to the most specific package takes * precedence over the others. For example, if <tt>javax.lang</tt> and * <tt>javax.lang.reflect</tt> both have package defaults associated with * them, the latter package default applies to classes in * <tt>javax.lang.reflect</tt>. * <p> Package defaults take precedence over the class loader's default * assertion status, and may be overridden on a per-class basis by invoking * {@link #setClassAssertionStatus(String, boolean)}. </p> * The name of the package whose package default assertion status * is to be set. A <tt>null</tt> value indicates the unnamed * package that is "current" * <cite>The Java™ Language Specification</cite>.) * <tt>true</tt> if classes loaded by this classloader and * belonging to the named package or any of its subpackages will * have assertions enabled by default, <tt>false</tt> if they will * have assertions disabled by default. * Sets the desired assertion status for the named top-level class in this * class loader and any nested classes contained therein. This setting * takes precedence over the class loader's default assertion status, and * over any applicable per-package default. This method has no effect if * the named class has already been initialized. (Once a class is * initialized, its assertion status cannot change.) * <p> If the named class is not a top-level class, this invocation will * have no effect on the actual assertion status of any class. </p> * The fully qualified class name of the top-level class whose * assertion status is to be set. * <tt>true</tt> if the named class is to have assertions * enabled when (and if) it is initialized, <tt>false</tt> if the * class is to have assertions disabled. * Sets the default assertion status for this class loader to * <tt>false</tt> and discards any package defaults or class assertion * status settings associated with the class loader. This method is * provided so that class loaders can be made to ignore any command line or * persistent assertion status settings and "start with a clean slate." * Whether or not "Java assertion maps" are initialized, set * them to empty maps, effectively ignoring any present settings. * Returns the assertion status that would be assigned to the specified * class if it were to be initialized at the time this method is invoked. * If the named class has had its assertion status set, the most recent * setting will be returned; otherwise, if any package default assertion * status pertains to this class, the most recent setting for the most * specific pertinent package default assertion status is returned; * otherwise, this class loader's default assertion status is returned. * The fully qualified class name of the class whose desired * assertion status is being queried. * @return The desired assertion status of the specified class. * @see #setClassAssertionStatus(String, boolean) * @see #setPackageAssertionStatus(String, boolean) * @see #setDefaultAssertionStatus(boolean) // assert classAssertionStatus != null; // assert packageAssertionStatus != null; // Check for a class entry // Check for most specific package entry // Return the classloader default // Set up the assertions with information provided by the VM. // Note: Should only be called inside a synchronized block // assert Thread.holdsLock(assertionLock); // Retrieves the assertion directives from the VM.