Classloaders and Classes
Classloaders and Classes (CLASSES)
An example of the classloader (CLASSES) section that includes Classloader summaries and Classloader loaded classes. Classloader summaries are the defined class loaders and the relationship between them. Classloader loaded classes are the classes that are loaded by each classloader.
See Class loading for information about the parent-delegation model.
In this example, there are the standard three classloaders:
- Application classloader (sun/misc/Launcher$AppClassLoader), which is a child of the extension classloader.
- The Extension classloader (sun/misc/Launcher$ExtClassLoader), which is a child of the bootstrap classloader.
- The Bootstrap classloader. Also known as the System classloader.
The example that follows shows this relationship. Take the application classloader with the full name sun/misc/Launcher$AppClassLoader. UnderClassloader summaries, it has flags -----ta-, which show that the class loader is t=trusted and a=application (See the example for information on class loader flags). It gives the number of loaded classes (1) and the parent classloader as sun/misc/Launcher$ExtClassLoader.
Under the ClassLoader loaded classes heading, you can see that the application classloader has loaded three classes, one called Test at address 0x41E6CFE0.
In this example, the System class loader has loaded a large number of classes, which provide the basic set from which all applications derive.
------------------------------------------------------------------------
CLASSES subcomponent dump routine
=================================
Classloader summaries
12345678: 1=primordial,2=extension,3=shareable,4=middleware,
5=system,6=trusted,7=application,8=delegating
p---st-- Loader *System*(0x00439130)
Number of loaded classes 306
-x--st-- Loader sun/misc/Launcher$ExtClassLoader(0x004799E8),
Parent *none*(0x00000000)
Number of loaded classes 0
-----ta- Loader sun/misc/Launcher$AppClassLoader(0x00484AD8),
Parent sun/misc/Launcher$ExtClassLoader(0x004799E8)
Number of loaded classes 1
ClassLoader loaded classes
Loader *System*(0x00439130)
java/security/CodeSource(0x41DA00A8)
java/security/PermissionCollection(0x41DA0690)
<< 301 classes removed for clarity >>
java/util/AbstractMap(0x4155A8C0)
java/io/OutputStream(0x4155ACB8)
java/io/FilterOutputStream(0x4155AE70)
Loader sun/misc/Launcher$ExtClassLoader(0x004799E8)
Loader sun/misc/Launcher$AppClassLoader(0x00484AD8)
Test(0x41E6CFE0)
Test$DeadlockThread0(0x41E6D410)
Test$DeadlockThread1(0x41E6D6E0)
Launcher.java :
// http://www.docjar.com/html/api/sun/misc/Launcher.java.html
1 /*
2 * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.misc;
27
28 import java.io.File;
29 import java.io.IOException;
30 import java.io.FilePermission;
31 import java.net.URL;
32 import java.net.URLClassLoader;
33 import java.net.MalformedURLException;
34 import java.net.URLStreamHandler;
35 import java.net.URLStreamHandlerFactory;
36 import java.util.HashSet;
37 import java.util.StringTokenizer;
38 import java.util.Set;
39 import java.util.Vector;
40 import java.security.AccessController;
41 import java.security.PrivilegedAction;
42 import java.security.PrivilegedExceptionAction;
43 import java.security.AccessControlContext;
44 import java.security.PermissionCollection;
45 import java.security.Permissions;
46 import java.security.Permission;
47 import java.security.ProtectionDomain;
48 import java.security.CodeSource;
49 import sun.security.util.SecurityConstants;
50 import sun.net.www.ParseUtil;
51
52 /**
53 * This class is used by the system to launch the main application.
54 Launcher */
55 public class Launcher {
56 private static URLStreamHandlerFactory factory = new Factory();
57 private static Launcher launcher = new Launcher();
58 private static String bootClassPath =
59 System.getProperty("sun.boot.class.path");
60
61 public static Launcher getLauncher() {
62 return launcher;
63 }
64
65 private ClassLoader loader;
66
67 public Launcher() {
68 // Create the extension class loader
69 ClassLoader extcl;
70 try {
71 extcl = ExtClassLoader.getExtClassLoader();
72 } catch (IOException e) {
73 throw new InternalError(
74 "Could not create extension class loader");
75 }
76
77 // Now create the class loader to use to launch the application
78 try {
79 loader = AppClassLoader.getAppClassLoader(extcl);
80 } catch (IOException e) {
81 throw new InternalError(
82 "Could not create application class loader");
83 }
84
85 // Also set the context class loader for the primordial thread.
86 Thread.currentThread().setContextClassLoader(loader);
87
88 // Finally, install a security manager if requested
89 String s = System.getProperty("java.security.manager");
90 if (s != null) {
91 SecurityManager sm = null;
92 if ("".equals(s) || "default".equals(s)) {
93 sm = new java.lang.SecurityManager();
94 } else {
95 try {
96 sm = (SecurityManager)loader.loadClass(s).newInstance();
97 } catch (IllegalAccessException e) {
98 } catch (InstantiationException e) {
99 } catch (ClassNotFoundException e) {
100 } catch (ClassCastException e) {
101 }
102 }
103 if (sm != null) {
104 System.setSecurityManager(sm);
105 } else {
106 throw new InternalError(
107 "Could not create SecurityManager: " + s);
108 }
109 }
110 }
111
112 /*
113 * Returns the class loader used to launch the main application.
114 */
115 public ClassLoader getClassLoader() {
116 return loader;
117 }
118
119 /*
120 * The class loader used for loading installed extensions.
121 */
122 static class ExtClassLoader extends URLClassLoader {
123
124 static {
125 ClassLoader.registerAsParallelCapable();
126 }
127
128 /**
129 * create an ExtClassLoader. The ExtClassLoader is created
130 * within a context that limits which files it can read
131 */
132 public static ExtClassLoader getExtClassLoader() throws IOException
133 {
134 final File[] dirs = getExtDirs();
135
136 try {
137 // Prior implementations of this doPrivileged() block supplied
138 // aa synthesized ACC via a call to the private method
139 // ExtClassLoader.getContext().
140
141 return AccessController.doPrivileged(
142 new PrivilegedExceptionAction<ExtClassLoader>() {
143 public ExtClassLoader run() throws IOException {
144 int len = dirs.length;
145 for (int i = 0; i < len; i++) {
146 MetaIndex.registerDirectory(dirs[i]);
147 }
148 return new ExtClassLoader(dirs);
149 }
150 });
151 } catch (java.security.PrivilegedActionException e) {
152 throw (IOException) e.getException();
153 }
154 }
155
156 void addExtURL(URL url) {
157 super.addURL(url);
158 }
159
160 /*
161 * Creates a new ExtClassLoader for the specified directories.
162 */
163 public ExtClassLoader(File[] dirs) throws IOException {
164 super(getExtURLs(dirs), null, factory);
165 }
166
167 private static File[] getExtDirs() {
168 String s = System.getProperty("java.ext.dirs");
169 File[] dirs;
170 if (s != null) {
171 StringTokenizer st =
172 new StringTokenizer(s, File.pathSeparator);
173 int count = st.countTokens();
174 dirs = new File[count];
175 for (int i = 0; i < count; i++) {
176 dirs[i] = new File(st.nextToken());
177 }
178 } else {
179 dirs = new File[0];
180 }
181 return dirs;
182 }
183
184 private static URL[] getExtURLs(File[] dirs) throws IOException {
185 Vector<URL> urls = new Vector<URL>();
186 for (int i = 0; i < dirs.length; i++) {
187 String[] files = dirs[i].list();
188 if (files != null) {
189 for (int j = 0; j < files.length; j++) {
190 if (!files[j].equals("meta-index")) {
191 File f = new File(dirs[i], files[j]);
192 urls.add(getFileURL(f));
193 }
194 }
195 }
196 }
197 URL[] ua = new URL[urls.size()];
198 urls.copyInto(ua);
199 return ua;
200 }
201
202 /*
203 * Searches the installed extension directories for the specified
204 * library name. For each extension directory, we first look for
205 * the native library in the subdirectory whose name is the value
206 * of the system property <code>os.arch</code>. Failing that, we
207 * look in the extension directory itself.
208 */
209 public String findLibrary(String name) {
210 name = System.mapLibraryName(name);
211 URL[] urls = super.getURLs();
212 File prevDir = null;
213 for (int i = 0; i < urls.length; i++) {
214 // Get the ext directory from the URL
215 File dir = new File(urls[i].getPath()).getParentFile();
216 if (dir != null && !dir.equals(prevDir)) {
217 // Look in architecture-specific subdirectory first
218 // Read from the saved system properties to avoid deadlock
219 String arch = VM.getSavedProperty("os.arch");
220 if (arch != null) {
221 File file = new File(new File(dir, arch), name);
222 if (file.exists()) {
223 return file.getAbsolutePath();
224 }
225 }
226 // Then check the extension directory
227 File file = new File(dir, name);
228 if (file.exists()) {
229 return file.getAbsolutePath();
230 }
231 }
232 prevDir = dir;
233 }
234 return null;
235 }
236
237 private static AccessControlContext getContext(File[] dirs)
238 throws IOException
239 {
240 PathPermissions perms =
241 new PathPermissions(dirs);
242
243 ProtectionDomain domain = new ProtectionDomain(
244 new CodeSource(perms.getCodeBase(),
245 (java.security.cert.Certificate[]) null),
246 perms);
247
248 AccessControlContext acc =
249 new AccessControlContext(new ProtectionDomain[] { domain });
250
251 return acc;
252 }
253 }
254
255 /**
256 * The class loader used for loading from java.class.path.
257 * runs in a restricted security context.
258 */
259 static class AppClassLoader extends URLClassLoader {
260
261 static {
262 ClassLoader.registerAsParallelCapable();
263 }
264
265 public static ClassLoader getAppClassLoader(final ClassLoader extcl)
266 throws IOException
267 {
268 final String s = System.getProperty("java.class.path");
269 final File[] path = (s == null) ? new File[0] : getClassPath(s);
270
271 // Note: on bugid 4256530
272 // Prior implementations of this doPrivileged() block supplied
273 // a rather restrictive ACC via a call to the private method
274 // AppClassLoader.getContext(). This proved overly restrictive
275 // when loading classes. Specifically it prevent
276 // accessClassInPackage.sun.* grants from being honored.
277 //
278 return AccessController.doPrivileged(
279 new PrivilegedAction<AppClassLoader>() {
280 public AppClassLoader run() {
281 URL[] urls =
282 (s == null) ? new URL[0] : pathToURLs(path);
283 return new AppClassLoader(urls, extcl);
284 }
285 });
286 }
287
288 /*
289 * Creates a new AppClassLoader
290 */
291 AppClassLoader(URL[] urls, ClassLoader parent) {
292 super(urls, parent, factory);
293 }
294
295 /**
296 * Override loadClass so we can checkPackageAccess.
297 */
298 public Class loadClass(String name, boolean resolve)
299 throws ClassNotFoundException
300 {
301 int i = name.lastIndexOf('.');
302 if (i != -1) {
303 SecurityManager sm = System.getSecurityManager();
304 if (sm != null) {
305 sm.checkPackageAccess(name.substring(0, i));
306 }
307 }
308 return (super.loadClass(name, resolve));
309 }
310
311 /**
312 * allow any classes loaded from classpath to exit the VM.
313 */
314 protected PermissionCollection getPermissions(CodeSource codesource)
315 {
316 PermissionCollection perms = super.getPermissions(codesource);
317 perms.add(new RuntimePermission("exitVM"));
318 return perms;
319 }
320
321 /**
322 * This class loader supports dynamic additions to the class path
323 * at runtime.
324 *
325 * @see java.lang.instrument.Instrumentation#appendToSystemClassPathSearch
326 */
327 private void appendToClassPathForInstrumentation(String path) {
328 assert(Thread.holdsLock(this));
329
330 // addURL is a no-op if path already contains the URL
331 super.addURL( getFileURL(new File(path)) );
332 }
333
334 /**
335 * create a context that can read any directories (recursively)
336 * mentioned in the class path. In the case of a jar, it has to
337 * be the directory containing the jar, not just the jar, as jar
338 * files might refer to other jar files.
339 */
340
341 private static AccessControlContext getContext(File[] cp)
342 throws java.net.MalformedURLException
343 {
344 PathPermissions perms =
345 new PathPermissions(cp);
346
347 ProtectionDomain domain =
348 new ProtectionDomain(new CodeSource(perms.getCodeBase(),
349 (java.security.cert.Certificate[]) null),
350 perms);
351
352 AccessControlContext acc =
353 new AccessControlContext(new ProtectionDomain[] { domain });
354
355 return acc;
356 }
357 }
358
359 private static class BootClassPathHolder {
360 static final URLClassPath bcp;
361 static {
362 URL[] urls;
363 if (bootClassPath != null) {
364 urls = AccessController.doPrivileged(
365 new PrivilegedAction<URL[]>() {
366 public URL[] run() {
367 File[] classPath = getClassPath(bootClassPath);
368 int len = classPath.length;
369 Set<File> seenDirs = new HashSet<File>();
370 for (int i = 0; i < len; i++) {
371 File curEntry = classPath[i];
372 // Negative test used to properly handle
373 // nonexistent jars on boot class path
374 if (!curEntry.isDirectory()) {
375 curEntry = curEntry.getParentFile();
376 }
377 if (curEntry != null && seenDirs.add(curEntry)) {
378 MetaIndex.registerDirectory(curEntry);
379 }
380 }
381 return pathToURLs(classPath);
382 }
383 }
384 );
385 } else {
386 urls = new URL[0];
387 }
388 bcp = new URLClassPath(urls, factory);
389 }
390 }
391
392 public static URLClassPath getBootstrapClassPath() {
393 return BootClassPathHolder.bcp;
394 }
395
396 private static URL[] pathToURLs(File[] path) {
397 URL[] urls = new URL[path.length];
398 for (int i = 0; i < path.length; i++) {
399 urls[i] = getFileURL(path[i]);
400 }
401 // DEBUG
402 //for (int i = 0; i < urls.length; i++) {
403 // System.out.println("urls[" + i + "] = " + '"' + urls[i] + '"');
404 //}
405 return urls;
406 }
407
408 private static File[] getClassPath(String cp) {
409 File[] path;
410 if (cp != null) {
411 int count = 0, maxCount = 1;
412 int pos = 0, lastPos = 0;
413 // Count the number of separators first
414 while ((pos = cp.indexOf(File.pathSeparator, lastPos)) != -1) {
415 maxCount++;
416 lastPos = pos + 1;
417 }
418 path = new File[maxCount];
419 lastPos = pos = 0;
420 // Now scan for each path component
421 while ((pos = cp.indexOf(File.pathSeparator, lastPos)) != -1) {
422 if (pos - lastPos > 0) {
423 path[count++] = new File(cp.substring(lastPos, pos));
424 } else {
425 // empty path component translates to "."
426 path[count++] = new File(".");
427 }
428 lastPos = pos + 1;
429 }
430 // Make sure we include the last path component
431 if (lastPos < cp.length()) {
432 path[count++] = new File(cp.substring(lastPos));
433 } else {
434 path[count++] = new File(".");
435 }
436 // Trim array to correct size
437 if (count != maxCount) {
438 File[] tmp = new File[count];
439 System.arraycopy(path, 0, tmp, 0, count);
440 path = tmp;
441 }
442 } else {
443 path = new File[0];
444 }
445 // DEBUG
446 //for (int i = 0; i < path.length; i++) {
447 // System.out.println("path[" + i + "] = " + '"' + path[i] + '"');
448 //}
449 return path;
450 }
451
452 private static URLStreamHandler fileHandler;
453
454 static URL getFileURL(File file) {
455 try {
456 file = file.getCanonicalFile();
457 } catch (IOException e) {}
458
459 try {
460 return ParseUtil.fileToEncodedURL(file);
461 } catch (MalformedURLException e) {
462 // Should never happen since we specify the protocol...
463 throw new InternalError();
464 }
465 }
466
467 /*
468 * The stream handler factory for loading system protocol handlers.
469 */
470 private static class Factory implements URLStreamHandlerFactory {
471 private static String PREFIX = "sun.net.www.protocol";
472
473 public URLStreamHandler createURLStreamHandler(String protocol) {
474 String name = PREFIX + "." + protocol + ".Handler";
475 try {
476 Class c = Class.forName(name);
477 return (URLStreamHandler)c.newInstance();
478 } catch (ClassNotFoundException e) {
479 e.printStackTrace();
480 } catch (InstantiationException e) {
481 e.printStackTrace();
482 } catch (IllegalAccessException e) {
483 e.printStackTrace();
484 }
485 throw new InternalError("could not load " + protocol +
486 "system protocol handler");
487 }
488 }
489 }
490
491 class PathPermissions extends PermissionCollection {
492 // use serialVersionUID from JDK 1.2.2 for interoperability
493 private static final long serialVersionUID = 8133287259134945693L;
494
495 private File path[];
496 private Permissions perms;
497
498 URL codeBase;
499
500 PathPermissions(File path[])
501 {
502 this.path = path;
503 this.perms = null;
504 this.codeBase = null;
505 }
506
507 URL getCodeBase()
508 {
509 return codeBase;
510 }
511
512 public void add(java.security.Permission permission) {
513 throw new SecurityException("attempt to add a permission");
514 }
515
516 private synchronized void init()
517 {
518 if (perms != null)
519 return;
520
521 perms = new Permissions();
522
523 // this is needed to be able to create the classloader itself!
524 perms.add(SecurityConstants.CREATE_CLASSLOADER_PERMISSION);
525
526 // add permission to read any "java.*" property
527 perms.add(new java.util.PropertyPermission("java.*",
528 SecurityConstants.PROPERTY_READ_ACTION));
529
530 AccessController.doPrivileged(new PrivilegedAction<Void>() {
531 public Void run() {
532 for (int i=0; i < path.length; i++) {
533 File f = path[i];
534 String path;
535 try {
536 path = f.getCanonicalPath();
537 } catch (IOException ioe) {
538 path = f.getAbsolutePath();
539 }
540 if (i == 0) {
541 codeBase = Launcher.getFileURL(new File(path));
542 }
543 if (f.isDirectory()) {
544 if (path.endsWith(File.separator)) {
545 perms.add(new FilePermission(path+"-",
546 SecurityConstants.FILE_READ_ACTION));
547 } else {
548 perms.add(new FilePermission(
549 path + File.separator+"-",
550 SecurityConstants.FILE_READ_ACTION));
551 }
552 } else {
553 int endIndex = path.lastIndexOf(File.separatorChar);
554 if (endIndex != -1) {
555 path = path.substring(0, endIndex+1) + "-";
556 perms.add(new FilePermission(path,
557 SecurityConstants.FILE_READ_ACTION));
558 } else {
559 // XXX?
560 }
561 }
562 }
563 return null;
564 }
565 });
566 }
567
568 public boolean implies(java.security.Permission permission) {
569 if (perms == null)
570 init();
571 return perms.implies(permission);
572 }
573
574 public java.util.Enumeration<Permission> elements() {
575 if (perms == null)
576 init();
577 synchronized (perms) {
578 return perms.elements();
579 }
580 }
581
582 public String toString() {
583 if (perms == null)
584 init();
585 return perms.toString();
586 }
587 }
