SecureClassLoader
public abstract class ClassLoader extends Object
ClassLoader
is an abstract class. Given the binary name of a class, a class loader should attempt to
locate or generate data that constitutes a definition for the class. A
typical strategy is to transform the name into a file name and then read a
"class file" of that name from a file system.
Every Class
object contains a reference
to the ClassLoader
that defined
it.
Class
objects for array classes are not created by class
loaders, but are created automatically as required by the Java runtime.
The class loader for an array class, as returned by Class.getClassLoader()
is the same as the class loader for its element
type; if the element type is a primitive type, then the array class has no
class loader.
Applications implement subclasses of ClassLoader
in order to
extend the manner in which the Java virtual machine dynamically loads
classes.
Class loaders may typically be used by security managers to indicate security domains.
The ClassLoader
class uses a delegation model to search for
classes and resources. Each instance of ClassLoader
has an
associated parent class loader. When requested to find a class or
resource, a ClassLoader
instance will delegate the search for the
class or resource to its parent class loader before attempting to find the
class or resource itself.
Class loaders that support concurrent loading of classes are known as
parallel capable class
loaders and are required to register themselves at their class initialization
time by invoking the ClassLoader.registerAsParallelCapable
method. Note that the ClassLoader
class is registered as parallel
capable by default. However, its subclasses still need to register themselves
if they are parallel capable.
In environments in which the delegation model is not strictly
hierarchical, class loaders need to be parallel capable, otherwise class
loading can lead to deadlocks because the loader lock is held for the
duration of the class loading process (see loadClass
methods).
null
, and does not have a parent.ClassLoader
instance.
Platform classes include Java SE platform APIs, their implementation
classes and JDK-specific run-time classes that are defined by the
platform class loader or its ancestors. Normally, the Java virtual machine loads classes from the local file
system in a platform-dependent manner.
However, some classes may not originate from a file; they may originate
from other sources, such as the network, or they could be constructed by an
application. The method defineClass
converts an array of bytes into an instance of class
Class
. Instances of this newly defined class can be created using
Class.newInstance
.
The methods and constructors of objects created by a class loader may
reference other classes. To determine the class(es) referred to, the Java
virtual machine invokes the loadClass
method of
the class loader that originally created the class.
For example, an application could create a network class loader to download class files from a server. Sample code might look like:
ClassLoader loader = new NetworkClassLoader(host, port); Object main = loader.loadClass("Main", true).newInstance(); . . .
The network class loader subclass must define the methods findClass
and loadClassData
to load a class
from the network. Once it has downloaded the bytes that make up the class,
it should use the method defineClass
to
create a class instance. A sample implementation is:
class NetworkClassLoader extends ClassLoader { String host; int port; public Class findClass(String name) { byte[] b = loadClassData(name); return defineClass(name, b, 0, b.length); } private byte[] loadClassData(String name) { // load the class data from the connection . . . } }
Any class name provided as a String
parameter to methods in
ClassLoader
must be a binary name as defined by
The Java™ Language Specification.
Examples of valid class names include:
"java.lang.String" "javax.swing.JSpinner$DefaultEditor" "java.security.KeyStore$Builder$FileBuilder$1" "java.net.URLClassLoader$3$1"
Any package name provided as a String
parameter to methods in
ClassLoader
must be either the empty string (denoting an unnamed package)
or a fully qualified name as defined by
The Java™ Language Specification.
resolveClass(Class)
Modifier | Constructor | Description |
---|---|---|
protected |
ClassLoader() |
Creates a new class loader using the
ClassLoader returned by
the method getSystemClassLoader() as the parent class loader. |
protected |
ClassLoader(ClassLoader parent) |
Creates a new class loader using the specified parent class loader for
delegation.
|
protected |
ClassLoader(String name,
ClassLoader parent) |
Creates a new class loader of the specified name and using the
specified parent class loader for delegation.
|
Modifier and Type | Method | Description |
---|---|---|
void |
clearAssertionStatus() |
Sets the default assertion status for this class loader to
false and discards any package defaults or class assertion
status settings associated with the class loader. |
protected Class<?> |
defineClass(byte[] b,
int off,
int len) |
Deprecated.
Replaced by
defineClass(String, byte[], int, int) |
protected Class<?> |
defineClass(String name,
byte[] b,
int off,
int len) |
Converts an array of bytes into an instance of class
Class . |
protected Class<?> |
defineClass(String name,
byte[] b,
int off,
int len,
ProtectionDomain protectionDomain) |
Converts an array of bytes into an instance of class
Class ,
with a given ProtectionDomain . |
protected Class<?> |
defineClass(String name,
ByteBuffer b,
ProtectionDomain protectionDomain) |
|
protected Package |
definePackage(String name,
String specTitle,
String specVersion,
String specVendor,
String implTitle,
String implVersion,
String implVendor,
URL sealBase) |
Defines a package by name in this
ClassLoader . |
protected Class<?> |
findClass(String name) |
Finds the class with the specified binary name.
|
protected Class<?> |
findClass(String moduleName,
String name) |
Finds the class with the given binary name
in a module defined to this class loader.
|
protected String |
findLibrary(String libname) |
Returns the absolute path name of a native library.
|
protected Class<?> |
findLoadedClass(String name) |
Returns the class with the given binary name if this
loader has been recorded by the Java virtual machine as an initiating
loader of a class with that binary name.
|
protected URL |
findResource(String name) |
Finds the resource with the given name.
|
protected URL |
findResource(String moduleName,
String name) |
Returns a URL to a resource in a module defined to this class loader.
|
protected Enumeration<URL> |
findResources(String name) |
Returns an enumeration of
URL objects
representing all the resources with the given name. |
protected Class<?> |
findSystemClass(String name) |
Finds a class with the specified binary name,
loading it if necessary.
|
protected Object |
getClassLoadingLock(String className) |
Returns the lock object for class loading operations.
|
Package |
getDefinedPackage(String name) |
Returns a
Package of the given name that has been
defined by this class loader. |
Package[] |
getDefinedPackages() |
Returns all of the
Package s defined by this class loader. |
String |
getName() |
Returns the name of this class loader or
null if
this class loader is not named. |
protected Package |
getPackage(String name) |
Deprecated.
If multiple class loaders delegate to each other and define classes
with the same package name, and one such loader relies on the lookup
behavior of
getPackage to return a Package from
a parent loader, then the properties exposed by the Package
may not be as expected in the rest of the program.
For example, the Package will only expose annotations from the
package-info.class file defined by the parent loader, even if
annotations exist in a package-info.class file defined by
a child loader. A more robust approach is to use the
getDefinedPackage(java.lang.String) method which returns
a Package for the specified class loader. |
protected Package[] |
getPackages() |
Returns all of the
Package s defined by this class loader
and its ancestors. |
ClassLoader |
getParent() |
Returns the parent class loader for delegation.
|
static ClassLoader |
getPlatformClassLoader() |
Returns the platform class loader for delegation.
|
URL |
getResource(String name) |
Finds the resource with the given name.
|
InputStream |
getResourceAsStream(String name) |
Returns an input stream for reading the specified resource.
|
Enumeration<URL> |
getResources(String name) |
Finds all the resources with the given name.
|
static ClassLoader |
getSystemClassLoader() |
Returns the system class loader for delegation.
|
static URL |
getSystemResource(String name) |
Find a resource of the specified name from the search path used to load
classes.
|
static InputStream |
getSystemResourceAsStream(String name) |
Open for reading, a resource of the specified name from the search path
used to load classes.
|
static Enumeration<URL> |
getSystemResources(String name) |
Finds all resources of the specified name from the search path used to
load classes.
|
Module |
getUnnamedModule() |
Returns the unnamed
Module for this class loader. |
boolean |
isRegisteredAsParallelCapable() |
|
Class<?> |
loadClass(String name) |
Loads the class with the specified binary name.
|
protected Class<?> |
loadClass(String name,
boolean resolve) |
Loads the class with the specified binary name.
|
protected static boolean |
registerAsParallelCapable() |
Registers the caller as
parallel capable.
|
protected void |
resolveClass(Class<?> c) |
Links the specified class.
|
Stream<URL> |
resources(String name) |
Returns a stream whose elements are the URLs of all the resources with
the given name.
|
void |
setClassAssertionStatus(String className,
boolean enabled) |
Sets the desired assertion status for the named top-level class in this
class loader and any nested classes contained therein.
|
void |
setDefaultAssertionStatus(boolean enabled) |
Sets the default assertion status for this class loader.
|
void |
setPackageAssertionStatus(String packageName,
boolean enabled) |
Sets the package default assertion status for the named package.
|
protected void |
setSigners(Class<?> c,
Object[] signers) |
Sets the signers of a class.
|
protected ClassLoader(String name, ClassLoader parent)
name
- class loader name; or null
if not namedparent
- the parent class loaderIllegalArgumentException
- if the given name is empty.SecurityException
- If a security manager exists and its
SecurityManager.checkCreateClassLoader()
method doesn't allow creation of a new class loader.protected ClassLoader(ClassLoader parent)
If there is a security manager, its checkCreateClassLoader
method is invoked. This may result in
a security exception.
parent
- The parent class loaderSecurityException
- If a security manager exists and its
checkCreateClassLoader
method doesn't allow creation
of a new class loader.protected ClassLoader()
ClassLoader
returned by
the method getSystemClassLoader()
as the parent class loader.
If there is a security manager, its checkCreateClassLoader
method is invoked. This may result in
a security exception.
SecurityException
- If a security manager exists and its
checkCreateClassLoader
method doesn't allow creation
of a new class loader.public String getName()
null
if
this class loader is not named.null
if
this class loader is not named.public Class<?> loadClass(String name) throws ClassNotFoundException
loadClass(String, boolean)
method. It is invoked by the Java virtual
machine to resolve class references. Invoking this method is equivalent
to invoking loadClass(name,
false)
.name
- The binary name of the classClass
objectClassNotFoundException
- If the class was not foundprotected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException
Invoke findLoadedClass(String)
to check if the class
has already been loaded.
Invoke the loadClass
method
on the parent class loader. If the parent is null
the class
loader built-in to the virtual machine is used, instead.
Invoke the findClass(String)
method to find the
class.
If the class was found using the above steps, and the
resolve
flag is true, this method will then invoke the resolveClass(Class)
method on the resulting Class
object.
Subclasses of ClassLoader
are encouraged to override findClass(String)
, rather than this method.
Unless overridden, this method synchronizes on the result of
getClassLoadingLock
method
during the entire class loading process.
name
- The binary name of the classresolve
- If true
then resolve the classClass
objectClassNotFoundException
- If the class could not be foundprotected Object getClassLoadingLock(String className)
className
- The name of the to-be-loaded classNullPointerException
- If registered as parallel capable and className
is nullloadClass(String, boolean)
protected Class<?> findClass(String name) throws ClassNotFoundException
loadClass
method after checking the
parent class loader for the requested class. The default implementation
throws a ClassNotFoundException
.name
- The binary name of the classClass
objectClassNotFoundException
- If the class could not be foundprotected Class<?> findClass(String moduleName, String name)
null
rather than throwing
ClassNotFoundException
if the class could not be found.findClass(String)
when the moduleName
is
null
. It otherwise returns null
.moduleName
- The module name; or null
to find the class in the
unnamed module for this
class loadername
- The binary name of the classClass
object, or null
if the class could not be found.@Deprecated(since="1.1") protected final Class<?> defineClass(byte[] b, int off, int len) throws ClassFormatError
defineClass(String, byte[], int, int)
Class
.
Before the Class
can be used it must be resolved. This method
is deprecated in favor of the version that takes a binary name as its first argument, and is more secure.b
- The bytes that make up the class data. The bytes in positions
off
through off+len-1
should have the format
of a valid class file as defined by
The Java™ Virtual Machine Specification.off
- The start offset in b
of the class datalen
- The length of the class dataClass
object that was created from the specified
class dataClassFormatError
- If the data did not contain a valid classIndexOutOfBoundsException
- If either off
or len
is negative, or if
off+len
is greater than b.length
.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 "java.
".loadClass(String, boolean)
,
resolveClass(Class)
protected final Class<?> defineClass(String name, byte[] b, int off, int len) throws ClassFormatError
Class
.
Before the Class
can be used it must be resolved.
This method assigns a default ProtectionDomain
to the newly defined class. The
ProtectionDomain
is effectively granted the same set of
permissions returned when Policy.getPolicy().getPermissions(new CodeSource(null, null))
is invoked. The default protection domain is created on the first invocation
of defineClass
,
and re-used on subsequent invocations.
To assign a specific ProtectionDomain
to the class, use
the defineClass
method that takes a
ProtectionDomain
as one of its arguments.
This method defines a package in this class loader corresponding to the
package of the Class
(if such a package has not already been defined
in this class loader). The name of the defined package is derived from
the binary name of the class specified by
the byte array b
.
Other properties of the defined package are as specified by Package
.
name
- The expected binary name of the class, or
null
if not knownb
- The bytes that make up the class data. The bytes in positions
off
through off+len-1
should have the format
of a valid class file as defined by
The Java™ Virtual Machine Specification.off
- The start offset in b
of the class datalen
- The length of the class dataClass
object that was created from the specified
class data.ClassFormatError
- If the data did not contain a valid classIndexOutOfBoundsException
- If either off
or len
is negative, or if
off+len
is greater than b.length
.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
name
begins with "java.
".loadClass(String, boolean)
,
resolveClass(Class)
,
CodeSource
,
SecureClassLoader
protected final Class<?> defineClass(String name, byte[] b, int off, int len, ProtectionDomain protectionDomain) throws ClassFormatError
Class
,
with a given ProtectionDomain
.
If the given ProtectionDomain
is null
,
then a default protection domain will be assigned to the class as specified
in the documentation for defineClass(String, byte[], int, int)
.
Before the class can be used it must be resolved.
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
CodeSource
within the
ProtectionDomain
of the class. Any classes added to that
package must contain the same set of certificates or a
SecurityException
will be thrown. Note that if
name
is null
, this check is not performed.
You should always pass in the binary name 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.
If the specified name
begins with "java.
", it can
only be defined by the platform class loader or its ancestors; otherwise SecurityException
will be thrown. If name
is not null
, it must be equal to
the binary name of the class
specified by the byte array b
, otherwise a NoClassDefFoundError
will be thrown.
This method defines a package in this class loader corresponding to the
package of the Class
(if such a package has not already been defined
in this class loader). The name of the defined package is derived from
the binary name of the class specified by
the byte array b
.
Other properties of the defined package are as specified by Package
.
name
- The expected binary name of the class, or
null
if not knownb
- The bytes that make up the class data. The bytes in positions
off
through off+len-1
should have the format
of a valid class file as defined by
The Java™ Virtual Machine Specification.off
- The start offset in b
of the class datalen
- The length of the class dataprotectionDomain
- The ProtectionDomain
of the classClass
object created from the data,
and ProtectionDomain
.ClassFormatError
- If the data did not contain a valid classNoClassDefFoundError
- If name
is not null
and not equal to the
binary name of the class specified by b
IndexOutOfBoundsException
- If either off
or len
is negative, or if
off+len
is greater than b.length
.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 name
begins with
"java.
" and this class loader is not the platform
class loader or its ancestor.protected final Class<?> defineClass(String name, ByteBuffer b, ProtectionDomain protectionDomain) throws ClassFormatError
ByteBuffer
into an instance
of class Class
, with the given ProtectionDomain
.
If the given ProtectionDomain
is null
, then a default
protection domain will be assigned to the class as
specified in the documentation for defineClass(String, byte[],
int, int)
. Before the class can be used it must be resolved.
The rules about the first class defined in a package determining the
set of certificates for the package, the restrictions on class names,
and the defined package of the class
are identical to those specified in the documentation for defineClass(String, byte[], int, int, ProtectionDomain)
.
An invocation of this method of the form
cl.defineClass(
name,
bBuffer,
pd)
yields exactly the same
result as the statements
...
byte[] temp = new byte[bBuffer.remaining
()];
bBuffer.get
(temp);
return cl.defineClass
(name, temp, 0,
temp.length, pd);
name
- The expected binary name. of the class, or
null
if not knownb
- The bytes that make up the class data. The bytes from positions
b.position()
through b.position() + b.limit() -1
should have the format of a valid class file as defined by
The Java™ Virtual Machine Specification.protectionDomain
- The ProtectionDomain
of the class, or null
.Class
object created from the data,
and ProtectionDomain
.ClassFormatError
- If the data did not contain a valid class.NoClassDefFoundError
- If name
is not null
and not equal to the
binary name of the class specified by b
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 name
begins with
"java.
".defineClass(String, byte[], int, int, ProtectionDomain)
protected final void resolveClass(Class<?> c)
c
has
already been linked, then this method simply returns. Otherwise, the
class is linked as described in the "Execution" chapter of
The Java™ Language Specification.c
- The class to linkNullPointerException
- If c
is null
.defineClass(String, byte[], int, int)
protected final Class<?> findSystemClass(String name) throws ClassNotFoundException
This method loads the class through the system class loader (see
getSystemClassLoader()
). The Class
object returned
might have more than one ClassLoader
associated with it.
Subclasses of ClassLoader
need not usually invoke this method,
because most class loaders need to override just findClass(String)
.
name
- The binary name of the classClass
object for the specified name
ClassNotFoundException
- If the class could not be foundClassLoader(ClassLoader)
,
getParent()
protected final Class<?> findLoadedClass(String name)
null
is returned.name
- The binary name of the classClass
object, or null
if the class has
not been loadedprotected final void setSigners(Class<?> c, Object[] signers)
c
- The Class
objectsigners
- The signers for the classprotected URL findResource(String moduleName, String name) throws IOException
Class.getResource
, Class.getResourceAsStream
, and Module.getResourceAsStream
methods. It is not subject to the rules for
encapsulation specified by Module.getResourceAsStream
.findResource(String)
when the moduleName
is
null
. It otherwise returns null
.moduleName
- The module name; or null
to find a resource in the
unnamed module for this
class loadername
- The resource namenull
if the resource could not be
found, a URL could not be constructed to locate the resource,
access to the resource is denied by the security manager, or
there isn't a module of the given name defined to the class
loader.IOException
- If I/O errors occurModuleReader.find(String)
public URL getResource(String name)
The name of a resource is a '/
'-separated path name that
identifies the resource.
This method will first search the parent class loader for the
resource; if the parent is null
the path of the class loader
built-in to the virtual machine is searched. That failing, this method
will invoke findResource(String)
to find the resource.
Resources in named modules are subject to the encapsulation rules
specified by Module.getResourceAsStream
.
Additionally, and except for the special case where the resource has a
name ending with ".class
", this method will only find resources in
packages of named modules when the package is opened
unconditionally (even if the caller of this method is in the
same module as the resource).
getResources(String)
method.name
- The resource nameURL
object for reading the resource; null
if
the resource could not be found, a URL
could not be
constructed to locate the resource, the resource is in a package
that is not opened unconditionally, or access to the resource is
denied by the security manager.NullPointerException
- If name
is null
public Enumeration<URL> getResources(String name) throws IOException
The name of a resource is a /
-separated path name that
identifies the resource.
The delegation order for searching is described in the documentation
for getResource(String)
.
Resources in named modules are subject to the encapsulation rules
specified by Module.getResourceAsStream
.
Additionally, and except for the special case where the resource has a
name ending with ".class
", this method will only find resources in
packages of named modules when the package is opened
unconditionally (even if the caller of this method is in the
same module as the resource).
getResource(String)
method. This should
ensure that the first element returned by the Enumeration's
nextElement
method is the same resource that the
getResource(String)
method would return.name
- The resource nameURL
objects for
the resource. If no resources could be found, the enumeration
will be empty. Resources for which a URL
cannot be
constructed, are in package that is not opened unconditionally,
or access to the resource is denied by the security manager,
are not returned in the enumeration.IOException
- If I/O errors occurNullPointerException
- If name
is null
findResources(String)
public Stream<URL> resources(String name)
The name of a resource is a /
-separated path name that
identifies the resource.
The search order is described in the documentation for getResource(String)
.
The resources will be located when the returned stream is evaluated.
If the evaluation results in an IOException
then the I/O
exception is wrapped in an UncheckedIOException
that is then
thrown.
Resources in named modules are subject to the encapsulation rules
specified by Module.getResourceAsStream
.
Additionally, and except for the special case where the resource has a
name ending with ".class
", this method will only find resources in
packages of named modules when the package is opened
unconditionally (even if the caller of this method is in the
same module as the resource).
getResource(String)
method. This should
ensure that the first element returned by the stream is the same
resource that the getResource(String)
method would return.name
- The resource nameURL
objects. If no
resources could be found, the stream will be empty. Resources
for which a URL
cannot be constructed, are in a package
that is not opened unconditionally, or access to the resource
is denied by the security manager, will not be in the stream.NullPointerException
- If name
is null
findResources(String)
protected URL findResource(String name)
For resources in named modules then the method must implement the
rules for encapsulation specified in the Module
getResourceAsStream
method. Additionally,
it must not find non-".class
" resources in packages of named
modules unless the package is opened
unconditionally.
name
- The resource nameURL
object for reading the resource; null
if
the resource could not be found, a URL
could not be
constructed to locate the resource, the resource is in a package
that is not opened unconditionally, or access to the resource is
denied by the security manager.protected Enumeration<URL> findResources(String name) throws IOException
URL
objects
representing all the resources with the given name. Class loader
implementations should override this method to specify where to load
resources from.
For resources in named modules then the method must implement the
rules for encapsulation specified in the Module
getResourceAsStream
method. Additionally,
it must not find non-".class
" resources in packages of named
modules unless the package is opened
unconditionally.
name
- The resource nameURL
objects for
the resource. If no resources could be found, the enumeration
will be empty. Resources for which a URL
cannot be
constructed, are in a package that is not opened unconditionally,
or access to the resource is denied by the security manager,
are not returned in the enumeration.IOException
- If I/O errors occurprotected static boolean registerAsParallelCapable()
Note that once a class loader is registered as parallel capable, there is no way to change it back.
true
if the caller is successfully registered as
parallel capable and false
if otherwise.isRegisteredAsParallelCapable()
public final boolean isRegisteredAsParallelCapable()
true
if this class loader is parallel capable,
otherwise false
.registerAsParallelCapable()
public static URL getSystemResource(String name)
getSystemClassLoader()
).
Resources in named modules are subject to the encapsulation rules
specified by Module.getResourceAsStream
.
Additionally, and except for the special case where the resource has a
name ending with ".class
", this method will only find resources in
packages of named modules when the package is opened
unconditionally.
name
- The resource nameURL
to the resource;
null
if the resource could not be found, a URL could not be
constructed to locate the resource, the resource is in a package
that is not opened unconditionally or access to the resource is
denied by the security manager.public static Enumeration<URL> getSystemResources(String name) throws IOException
Enumeration
of URL
objects.
The search order is described in the documentation for getSystemResource(String)
.
Resources in named modules are subject to the encapsulation rules
specified by Module.getResourceAsStream
.
Additionally, and except for the special case where the resource has a
name ending with ".class
", this method will only find resources in
packages of named modules when the package is opened
unconditionally.
name
- The resource nameURL
objects for
the resource. If no resources could be found, the enumeration
will be empty. Resources for which a URL
cannot be
constructed, are in a package that is not opened unconditionally,
or access to the resource is denied by the security manager,
are not returned in the enumeration.IOException
- If I/O errors occurpublic InputStream getResourceAsStream(String name)
The search order is described in the documentation for getResource(String)
.
Resources in named modules are subject to the encapsulation rules
specified by Module.getResourceAsStream
.
Additionally, and except for the special case where the resource has a
name ending with ".class
", this method will only find resources in
packages of named modules when the package is opened
unconditionally.
name
- The resource namenull
if the
resource could not be found, the resource is in a package that
is not opened unconditionally, or access to the resource is
denied by the security manager.NullPointerException
- If name
is null
public static InputStream getSystemResourceAsStream(String name)
getSystemClassLoader()
).
Resources in named modules are subject to the encapsulation rules
specified by Module.getResourceAsStream
.
Additionally, and except for the special case where the resource has a
name ending with ".class
", this method will only find resources in
packages of named modules when the package is opened
unconditionally.
name
- The resource namenull
if the
resource could not be found, the resource is in a package that
is not opened unconditionally, or access to the resource is
denied by the security manager.public final ClassLoader getParent()
null
to represent the bootstrap class loader. This method
will return null
in such implementations if this class loader's
parent is the bootstrap class loader.ClassLoader
SecurityException
- If a security manager is present, and the caller's class loader
is not null
and is not an ancestor of this class loader,
and the caller does not have the
RuntimePermission
("getClassLoader")
public final Module getUnnamedModule()
Module
for this class loader.Module.isNamed()
public static ClassLoader getPlatformClassLoader()
"platform"
.ClassLoader
.SecurityException
- If a security manager is present, and the caller's class loader is
not null
, and the caller's class loader is not the same
as or an ancestor of the platform class loader,
and the caller does not have the
RuntimePermission
("getClassLoader")
public static ClassLoader getSystemClassLoader()
ClassLoader
instances, and is
typically the class loader used to start the application.
This method is first invoked early in the runtime's startup
sequence, at which point it creates the system class loader. This
class loader will be the context class loader for the main application
thread (for example, the thread that invokes the main
method of
the main class).
The default system class loader is an implementation-dependent instance of this class.
If the system property "java.system.class.loader
" 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 ClassLoader
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. During construction, the class loader
should take great care to avoid calling getSystemClassLoader()
.
If circular initialization of the system class loader is detected then
an unspecified error or exception is thrown.
The name of the built-in system class loader is "app"
.
The class path used by the built-in system class loader is determined
by the system property "java.class.path
" during early
initialization of the VM. If the system property is not defined,
or its value is an empty string, then there is no class path
when the initial module is a module on the application module path,
i.e. a named module. If the initial module is not on
the application module path then the class path defaults to
the current working directory.
ClassLoader
for delegationSecurityException
- If a security manager is present, and the caller's class loader
is not null
and is not the same as or an ancestor of the
system class loader, and the caller does not have the
RuntimePermission
("getClassLoader")
IllegalStateException
- If invoked recursively during the construction of the class
loader specified by the "java.system.class.loader
"
property.Error
- If the system property "java.system.class.loader
"
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
Throwable.getCause()
method.protected Package definePackage(String name, String specTitle, String specVersion, String specVendor, String implTitle, String implVersion, String implVendor, URL sealBase)
ClassLoader
.
Package names must be unique within a class loader and cannot be redefined or changed once created.
If a class loader wishes to define a package with specific properties,
such as version information, then the class loader should call this
definePackage
method before calling defineClass
.
Otherwise, the
defineClass
method will define a package in this class loader corresponding to the package
of the newly defined class; the properties of this defined package are
specified by Package
.
URL
of the JAR file is typically used as the sealBase
.
If classes of package 'p'
defined by this class loader
are loaded from multiple JARs, the Package
object may contain
different information depending on the first class of package 'p'
defined and which JAR's manifest is read first to explicitly define
package 'p'
.
It is strongly recommended that a class loader does not call this
method to explicitly define packages in named modules; instead,
the package will be automatically defined when a class is being defined.
If it is desirable to define Package
explicitly, it should ensure
that all packages in a named module are defined with the properties
specified by Package
. Otherwise, some Package
objects
in a named module may be for example sealed with different seal base.
name
- The package namespecTitle
- The specification titlespecVersion
- The specification versionspecVendor
- The specification vendorimplTitle
- The implementation titleimplVersion
- The implementation versionimplVendor
- The implementation vendorsealBase
- If not null
, then this package is sealed with
respect to the given code source URL
object. Otherwise, the package is not sealed.Package
objectNullPointerException
- if name
is null
.IllegalArgumentException
- if a package of the given name
is already
defined by this class loaderpublic final Package getDefinedPackage(String name)
Package
of the given name that has been
defined by this class loader.name
- The package namePackage
of the given name defined by this class loader,
or null
if not foundNullPointerException
- if name
is null
.public final Package[] getDefinedPackages()
Package
s defined by this class loader.
The returned array has no duplicated Package
s of the same name.Set
or Stream
for consistency with the existing getPackages()
method.Package
objects defined by this class loader;
or an zero length array if no package has been defined by this class loader.@Deprecated(since="9") protected Package getPackage(String name)
getPackage
to return a Package
from
a parent loader, then the properties exposed by the Package
may not be as expected in the rest of the program.
For example, the Package
will only expose annotations from the
package-info.class
file defined by the parent loader, even if
annotations exist in a package-info.class
file defined by
a child loader. A more robust approach is to use the
getDefinedPackage(java.lang.String)
method which returns
a Package
for the specified class loader.
If this class loader defines a Package
of the given name,
the Package
is returned. Otherwise, the ancestors of
this class loader are searched recursively (parent by parent)
for a Package
of the given name.
name
- The package namePackage
corresponding to the given name defined by
this class loader or its ancestors, or null
if not found.NullPointerException
- if name
is null
.protected Package[] getPackages()
Package
s defined by this class loader
and its ancestors. The returned array may contain more than one
Package
object of the same package name, each defined by
a different class loader in the class loader hierarchy.Package
objects defined by this
class loader and its ancestorsprotected String findLibrary(String libname)
null
, the VM
searches the library along the path specified as the
"java.library.path
" property.libname
- The library nameSystem.loadLibrary(String)
,
System.mapLibraryName(String)
public void setDefaultAssertionStatus(boolean enabled)
setPackageAssertionStatus(String, boolean)
or setClassAssertionStatus(String, boolean)
.enabled
- true
if classes loaded by this class loader will
henceforth have assertions enabled by default, false
if they will have assertions disabled by default.public void setPackageAssertionStatus(String packageName, boolean enabled)
A subpackage of a package named p is any package whose name begins
with "p.
". For example, javax.swing.text
is a
subpackage of javax.swing
, and both java.util
and
java.lang.reflect
are subpackages of java
.
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 javax.lang
and
javax.lang.reflect
both have package defaults associated with
them, the latter package default applies to classes in
javax.lang.reflect
.
Package defaults take precedence over the class loader's default
assertion status, and may be overridden on a per-class basis by invoking
setClassAssertionStatus(String, boolean)
.
packageName
- The name of the package whose package default assertion status
is to be set. A null
value indicates the unnamed
package that is "current"
(see section 7.4.2 of
The Java™ Language Specification.)enabled
- true
if classes loaded by this classloader and
belonging to the named package or any of its subpackages will
have assertions enabled by default, false
if they will
have assertions disabled by default.public void setClassAssertionStatus(String className, boolean enabled)
If the named class is not a top-level class, this invocation will have no effect on the actual assertion status of any class.
className
- The fully qualified class name of the top-level class whose
assertion status is to be set.enabled
- true
if the named class is to have assertions
enabled when (and if) it is initialized, false
if the
class is to have assertions disabled.public void clearAssertionStatus()
false
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." Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2017, Oracle and/or its affiliates. 500 Oracle Parkway
Redwood Shores, CA 94065 USA. All rights reserved.
DRAFT 9-internal+0-adhoc.mlchung.jdk9-jdeps