jdk-sandbox: comparison jdk/src/java.base/share/classes/java/lang/ClassLoader.java

equal deleted inserted replaced

-:7a4a59859ac0
+:a60f280f803c
 import java.security.ProtectionDomain;
 import java.security.cert.Certificate;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.Map;
+import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.Set;
 import java.util.Spliterator;
 import java.util.Spliterators;
 import java.util.Stack;
-import java.util.NoSuchElementException;
 import java.util.Vector;
 import java.util.WeakHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 import jdk.internal.perf.PerfCounter;
-import jdk.internal.module.ServicesCatalog;
 import jdk.internal.loader.BootLoader;
 import jdk.internal.loader.ClassLoaders;
 import jdk.internal.misc.SharedSecrets;
 import jdk.internal.misc.Unsafe;
 import jdk.internal.misc.VM;
 */
 protected ClassLoader(ClassLoader parent) {
 this(checkCreateClassLoader(), null, parent);
 }
 /**
 * Creates a new class loader using the <tt>ClassLoader</tt> returned by
 * the method {@link #getSystemClassLoader()
 * <tt>getSystemClassLoader()</tt>} as the parent class loader.
 *
 *          of a new class loader.
 */
 protected ClassLoader() {
 this(checkCreateClassLoader(), null, getSystemClassLoader());
 }
 /**
 * Returns the name of this class loader or {@code null} if
 * this class loader is not named.
 *
 *         The <a href="#name">binary name</a> of the class
 *
 * @return The resulting {@code Class} object in a module defined by
 *         this class loader, or {@code null} if the class could not be found.
 */
-final Class<?> loadLocalClass(Module module, String name) {
+final Class<?> loadClass(Module module, String name) {
 synchronized (getClassLoadingLock(name)) {
 // First, check if the class has already been loaded
 Class<?> c = findLoadedClass(name);
 if (c == null) {
 c = findClass(module.getName(), name);
 if (c != null && c.getModule() == module) {
 return c;
 } else {
 return null;
 }
-}
-}
-/**
-* Loads the class with the specified <a href="#name">binary name</a>
-* defined by this class loader.  This method returns {@code null}
-* if the class could not be found.
-*
-* @apiNote This method does not delegate to the parent class loader.
-*
-* @param  name
-*         The <a href="#name">binary name</a> of the class
-*
-* @return The resulting {@code Class} object in a module defined by
-*         this class loader, or {@code null} if the class could not be found.
-*/
-final Class<?> loadLocalClass(String name) {
-synchronized (getClassLoadingLock(name)) {
-// First, check if the class has already been loaded
-Class<?> c = findLoadedClass(name);
-if (c == null) {
-try {
-return findClass(name);
-} catch (ClassNotFoundException e) {
-// ignore
-}
-}
-return c;
 }
 }
 /**
 * Returns the lock object for class loading operations.
 * in a module defined to this class loader.
 * Class loader implementations that support the loading from modules
 * should override this method.
 *
 * @apiNote This method returns {@code null} rather than throwing
-*          {@code ClassNotFoundException} if the class could not be found
+*          {@code ClassNotFoundException} if the class could not be found.
 *
-* @implSpec The default implementation returns {@code null}.
+* @implSpec The default implementation attempts to find the class by
+* invoking {@link #findClass(String)} when the {@code moduleName} is
+* {@code null}. It otherwise returns {@code null}.
 *
 * @param  moduleName
-*         The module name
+*         The module name; or {@code null} to find the class in the
+*         {@linkplain #getUnnamedModule() unnamed module} for this
+*         class loader
 * @param  name
 *         The <a href="#name">binary name</a> of the class
 *
 * @return The resulting {@code Class} object, or {@code null}
 *         if the class could not be found.
 *
 * @since 9
 */
 protected Class<?> findClass(String moduleName, String name) {
+if (moduleName == null) {
+try {
+return findClass(name);
+} catch (ClassNotFoundException ignore) { }
+}
 return null;
 }
 /**
 /**
 * Returns a URL to a resource in a module defined to this class loader.
 * Class loader implementations that support the loading from modules
 * should override this method.
 *
-* @implSpec The default implementation returns {@code null}.
+* @apiNote This method is the basis for the {@code Class} {@link
+* Class#getResource getResource} and {@link Class#getResourceAsStream
+* getResourceAsStream} methods. It is not subject to the rules for
+* encapsulation specified by {@code Module} {@link
+* Module#getResourceAsStream getResourceAsStream}.
+*
+* @implSpec The default implementation attempts to find the resource by
+* invoking {@link #findResource(String)} when the {@code moduleName} is
+* {@code null}. It otherwise returns {@code null}.
 *
 * @param  moduleName
-*         The module name
+*         The module name; or {@code null} to find a resource in the
+*         {@linkplain #getUnnamedModule() unnamed module} for this
+*         class loader
 * @param  name
 *         The resource name
 *
 * @return A URL to the resource; {@code null} if the resource could not be
 *         found, a URL could not be constructed to locate the resource,
 *
 * @see java.lang.module.ModuleReader#find(String)
 * @since 9
 */
 protected URL findResource(String moduleName, String name) throws IOException {
-return null;
+if (moduleName == null) {
+return findResource(name);
+} else {
+return null;
+}
 }
 /**
 * 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.
-*
-* Resources in a named module are private to that module. This method does
-* not find resource in named modules.
 *
 * <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>
 *
-* @apiNote When overriding this method it is recommended that an
+* <p> Resources in named modules are subject to the encapsulation rules
-* implementation ensures that any delegation is consistent with the {@link
+* specified by {@link Module#getResourceAsStream Module.getResourceAsStream}.
+* Additionally, and except for the special case where the resource has a
+* name ending with "{@code .class}", this method will only find resources in
+* packages of named modules when the package is {@link Module#isOpen(String)
+* opened} unconditionally (even if the caller of this method is in the
+* same module as the resource). </p>
+*
+* @apiNote Where several modules are defined to the same class loader,
+* and where more than one module contains a resource with the given name,
+* then the ordering that modules are searched is not specified and may be
+* very unpredictable.
+* When overriding this method it is recommended that an implementation
+* ensures that any delegation is consistent with the {@link
 * #getResources(java.lang.String) getResources(String)} method.
 *
 * @param  name
 *         The resource name
 *
-* @return  A <tt>URL</tt> object for reading the resource, or
+* @return  {@code URL} object for reading the resource; {@code null} if
-*          <tt>null</tt> if the resource could not be found or the invoker
+*          the resource could not be found, a {@code URL} could not be
-*          doesn't have adequate  privileges to get the resource.
+*          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.
 *
 * @since  1.1
 */
 public URL getResource(String name) {
 URL url;
 /**
 * 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.
 *
-* Resources in a named module are private to that module. This method does
+* <p> The name of a resource is a <tt>/</tt>-separated path name that
-* not find resources in named modules.
-*
-* <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
+* <p> The delegation order for searching is described in the documentation
-* #getResource(String)}.  </p>
+* for {@link #getResource(String)}.  </p>
 *
-* @apiNote When overriding this method it is recommended that an
+* <p> Resources in named modules are subject to the encapsulation rules
+* specified by {@link Module#getResourceAsStream Module.getResourceAsStream}.
+* Additionally, and except for the special case where the resource has a
+* name ending with "{@code .class}", this method will only find resources in
+* packages of named modules when the package is {@link Module#isOpen(String)
+* opened} unconditionally (even if the caller of this method is in the
+* same module as the resource).</p>
+*
+* @apiNote Where several modules are defined to the same class loader,
+* and where more than one module contains a resource with the given name,
+* then the ordering is not specified and may be very unpredictable.
+* When overriding this method it is recommended that an
 * implementation ensures that any delegation is consistent with the {@link
 * #getResource(java.lang.String) getResource(String)} method. This should
 * ensure that the first element returned by the Enumeration's
 * {@code nextElement} method is the same resource that the
 * {@code getResource(String)} method would return.
 *
 * @param  name
 *         The resource name
 *
 * @return  An enumeration of {@link java.net.URL <tt>URL</tt>} objects for
-*          the resource.  If no resources could  be found, the enumeration
+*          the resource. If no resources could  be found, the enumeration
-*          will be empty.  Resources that the class loader doesn't have
+*          will be empty. Resources for which a {@code URL} cannot be
-*          access to will not be in the enumeration.
+*          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.
 *
 * @throws  IOException
 *          If I/O errors occur
 *
 * @see  #findResources(String)
 * Returns a stream whose elements are the URLs of 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.
 *
-* Resources in a named module are private to that module. This method does
-* not find resources in named modules.
-*
 * <p> The name of a resource is a {@code /}-separated path name that
 * identifies the resource.
 *
 * <p> The search order is described in the documentation for {@link
 * #getResource(String)}.
 *
 * <p> The resources will be located when the returned stream is evaluated.
 * If the evaluation results in an {@code IOException} then the I/O
 * exception is wrapped in an {@link UncheckedIOException} that is then
 * thrown.
+*
+* <p> Resources in named modules are subject to the encapsulation rules
+* specified by {@link Module#getResourceAsStream Module.getResourceAsStream}.
+* Additionally, and except for the special case where the resource has a
+* name ending with "{@code .class}", this method will only find resources in
+* packages of named modules when the package is {@link Module#isOpen(String)
+* opened} unconditionally (even if the caller of this method is in the
+* same module as the resource). </p>
 *
 * @apiNote When overriding this method it is recommended that an
 * implementation ensures that any delegation is consistent with the {@link
 * #getResource(java.lang.String) getResource(String)} method. This should
 * ensure that the first element returned by the stream is the same
 *
 * @param  name
 *         The resource name
 *
 * @return  A stream of resource {@link java.net.URL URL} objects. If no
-*          resources could  be found, the stream will be empty.  Resources
+*          resources could  be found, the stream will be empty. Resources
-*          that the class loader doesn't have access to will not be in the
+*          for which a {@code URL} cannot be constructed, are in a package
-*          stream.
+*          that is not opened unconditionally, or access to the resource
+*          is denied by the security manager, will not be in the stream.
 *
 * @see  #findResources(String)
 *
 * @since  9
 */
 /**
 * Finds the resource with the given name. Class loader implementations
 * should override this method to specify where to find resources.
 *
-* Resources in a named module are private to that module. This method does
+* <p> For resources in named modules then the method must implement the
-* not find resources in named modules defined to this class loader.
+* rules for encapsulation specified in the {@code Module} {@link
+* Module#getResourceAsStream getResourceAsStream} method. Additionally,
+* it must not find non-"{@code .class}" resources in packages of named
+* modules unless the package is {@link Module#isOpen(String) opened}
+* unconditionally. </p>
 *
 * @param  name
 *         The resource name
 *
-* @return  A <tt>URL</tt> object for reading the resource, or
+* @return  {@code URL} object for reading the resource; {@code null} if
-*          <tt>null</tt> if the resource could not be found
+*          the resource could not be found, a {@code 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.
 *
 * @since  1.2
 */
 protected URL findResource(String name) {
 return null;
 * 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
 * resources from.
 *
-* Resources in a named module are private to that module. This method does
+* <p> For resources in named modules then the method must implement the
-* not find resources in named modules defined to this class loader.
+* rules for encapsulation specified in the {@code Module} {@link
+* Module#getResourceAsStream getResourceAsStream} method. Additionally,
+* it must not find non-"{@code .class}" resources in packages of named
+* modules unless the package is {@link Module#isOpen(String) opened}
+* unconditionally. </p>
 *
 * @param  name
 *         The resource name
 *
 * @return  An enumeration of {@link java.net.URL <tt>URL</tt>} objects for
-*          the resources
+*          the resource. If no resources could  be found, the enumeration
+*          will be empty. Resources for which a {@code 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.
 *
 * @throws  IOException
 *          If I/O errors occur
 *
 * @since  1.2
 */
 protected Enumeration<URL> findResources(String name) throws IOException {
-return java.util.Collections.emptyEnumeration();
+return Collections.emptyEnumeration();
 }
 /**
 * Registers the caller as {@linkplain #isParallelCapable() parallel capable}.
 * The registration succeeds if and only if all of the following
 /**
 * 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()}).
 *
-* Resources in a named module are private to that module. This method does
+* <p> Resources in named modules are subject to the encapsulation rules
-* not find resources in named modules.
+* specified by {@link Module#getResourceAsStream Module.getResourceAsStream}.
+* Additionally, and except for the special case where the resource has a
+* name ending with "{@code .class}", this method will only find resources in
+* packages of named modules when the package is {@link Module#isOpen(String)
+* opened} unconditionally. </p>
 *
 * @param  name
 *         The resource name
 *
-* @return  A {@link java.net.URL <tt>URL</tt>} object for reading the
+* @return  A {@link java.net.URL <tt>URL</tt>} to the resource; {@code
-*          resource, or <tt>null</tt> if the resource could not be found
+*          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.
 *
 * @since  1.1
 */
 public static URL getSystemResource(String name) {
 return getSystemClassLoader().getResource(name);
 * 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.
 *
-* Resources in a named module are private to that module. This method does
-* not find resources in named modules.
-*
 * <p> The search order is described in the documentation for {@link
 * #getSystemResource(String)}.  </p>
 *
+* <p> Resources in named modules are subject to the encapsulation rules
+* specified by {@link Module#getResourceAsStream Module.getResourceAsStream}.
+* Additionally, and except for the special case where the resource has a
+* name ending with "{@code .class}", this method will only find resources in
+* packages of named modules when the package is {@link Module#isOpen(String)
+* opened} unconditionally. </p>
+*
 * @param  name
 *         The resource name
 *
-* @return  An enumeration of resource {@link java.net.URL <tt>URL</tt>}
+* @return  An enumeration of {@link java.net.URL <tt>URL</tt>} objects for
-*          objects
+*          the resource. If no resources could  be found, the enumeration
+*          will be empty. Resources for which a {@code 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.
 *
 * @throws  IOException
 *          If I/O errors occur
 *
 * @since  1.2
 }
 /**
 * Returns an input stream for reading the specified resource.
 *
-* Resources in a named module are private to that module. This method does
-* not find resources in named modules.
-*
 * <p> The search order is described in the documentation for {@link
 * #getResource(String)}.  </p>
 *
+* <p> Resources in named modules are subject to the encapsulation rules
+* specified by {@link Module#getResourceAsStream Module.getResourceAsStream}.
+* Additionally, and except for the special case where the resource has a
+* name ending with "{@code .class}", this method will only find resources in
+* packages of named modules when the package is {@link Module#isOpen(String)
+* opened} unconditionally. </p>
+*
 * @param  name
 *         The resource name
 *
-* @return  An input stream for reading the resource, or <tt>null</tt>
+* @return  An input stream for reading the resource; {@code null} if the
-*          if the resource could not be found
+*          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.
 *
 * @since  1.1
 */
 public InputStream getResourceAsStream(String name) {
 URL url = getResource(name);
 /**
 * 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()}).
 *
-* Resources in a named module are private to that module. This method does
+* <p> Resources in named modules are subject to the encapsulation rules
-* not find resources in named modules.
+* specified by {@link Module#getResourceAsStream Module.getResourceAsStream}.
+* Additionally, and except for the special case where the resource has a
+* name ending with "{@code .class}", this method will only find resources in
+* packages of named modules when the package is {@link Module#isOpen(String)
+* opened} unconditionally. </p>
 *
 * @param  name
 *         The resource name
 *
-* @return  An input stream for reading the resource, or <tt>null</tt>
+* @return  An input stream for reading the resource; {@code null} if the
-*          if the resource could not be found
+*          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.
 *
 * @since  1.1
 */
 public static InputStream getSystemResourceAsStream(String name) {
 URL url = getSystemResource(name);
 // Retrieves the assertion directives from the VM.
 private static native AssertionStatusDirectives retrieveDirectives();
-/**
+// -- Misc --
-* Returns the ServiceCatalog for modules defined to this class loader
-* or {@code null} if this class loader does not have a services catalog.
-*/
-ServicesCatalog getServicesCatalog() {
-return servicesCatalog;
-}
-/**
-* Returns the ServiceCatalog for modules defined to this class loader,
-* creating it if it doesn't already exist.
-*/
-ServicesCatalog createOrGetServicesCatalog() {
-ServicesCatalog catalog = servicesCatalog;
-if (catalog == null) {
-catalog = ServicesCatalog.create();
-boolean set = trySetObjectField("servicesCatalog", catalog);
-if (!set) {
-// beaten by someone else
-catalog = servicesCatalog;
-}
-}
-return catalog;
-}
-// the ServiceCatalog for modules associated with this class loader.
-private volatile ServicesCatalog servicesCatalog;
 /**
 * Returns the ConcurrentHashMap used as a storage for ClassLoaderValue(s)
 * associated with this ClassLoader, creating it if it doesn't already exist.
 */

changeset 42338	a60f280f803c
parent 41911	b3bb62588635
child 42339	455e651aa073