JDK 类加载源码

 

 

 

public class Launcher {
 static class AppClassLoader extends URLClassLoader {

  public static ClassLoader getAppClassLoader(ClassLoader classloader)
          throws IOException {
   String s = System.getProperty("java.class.path");
   File afile[] = s != null ? Launcher.getClassPath(s) : new File[0];
   return (AppClassLoader) AccessController
           .doPrivileged(new PrivilegedAction(s, afile, classloader) {

            public Object run() {
             URL aurl[] = s != null ? Launcher.pathToURLs(path)
                     : new URL[0];
             return new AppClassLoader(aurl, extcl);
            }

            final String val$s;

            final File val$path[];

            final ClassLoader val$extcl;

            {
             s = s1;
             path = afile;
             extcl = classloader;
             super();
            }
           });
  }

  public synchronized Class loadClass(String s, boolean flag)
          throws ClassNotFoundException {
   int i = s.lastIndexOf('.');
   if (i != -1) {
    SecurityManager securitymanager = System.getSecurityManager();
    if (securitymanager != null)
     securitymanager.checkPackageAccess(s.substring(0, i));
   }
   return super.loadClass(s, flag);
  }

  protected PermissionCollection getPermissions(CodeSource codesource) {
   PermissionCollection permissioncollection = super
           .getPermissions(codesource);
   permissioncollection.add(new RuntimePermission("exitVM"));
   return permissioncollection;
  }

  private static AccessControlContext getContext(File afile[])
          throws MalformedURLException {
   PathPermissions pathpermissions = new PathPermissions(afile);
   ProtectionDomain protectiondomain = new ProtectionDomain(
           new CodeSource(pathpermissions.getCodeBase(),
                   (java.security.cert.Certificate[]) null),
           pathpermissions);
   AccessControlContext accesscontrolcontext = new AccessControlContext(
           new ProtectionDomain[] { protectiondomain });
   return accesscontrolcontext;
  }

  AppClassLoader(URL aurl[], ClassLoader classloader) {
   super(aurl, classloader, Launcher.factory);
  }
 }

 static class ExtClassLoader extends URLClassLoader {

  public static ExtClassLoader getExtClassLoader()
            throws IOException
        {
            File afile[] = getExtDirs();
            try
            {
                return (ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction(afile) {

                    public Object run()
                        throws IOException
                    {
                        return new ExtClassLoader(dirs);
                    }

                    final File val$dirs[];

               
                    throws IOException
                {
                    dirs = afile;
                    super();
                }
                }
);
            }
            catch(PrivilegedActionException privilegedactionexception)
            {
                throw (IOException)privilegedactionexception.getException();
            }
        }

  void addExtURL(URL url) {
   super.addURL(url);
  }

  private static File[] getExtDirs() {
   String s = System.getProperty("java.ext.dirs");
   File afile[];
   if (s != null) {
    StringTokenizer stringtokenizer = new StringTokenizer(s,
            File.pathSeparator);
    int i = stringtokenizer.countTokens();
    afile = new File[i];
    for (int j = 0; j < i; j++)
     afile[j] = new File(stringtokenizer.nextToken());

   } else {
    afile = new File[0];
   }
   return afile;
  }

  private static URL[] getExtURLs(File afile[]) throws IOException {
   Vector vector = new Vector();
   for (int i = 0; i < afile.length; i++) {
    String as[] = afile[i].list();
    if (as == null)
     continue;
    for (int j = 0; j < as.length; j++) {
     File file = new File(afile[i], as[j]);
     vector.add(Launcher.getFileURL(file));
    }

   }

   URL aurl[] = new URL[vector.size()];
   vector.copyInto(aurl);
   return aurl;
  }

  public String findLibrary(String s) {
   s = System.mapLibraryName(s);
   for (int i = 0; i < dirs.length; i++) {
    String s1 = System.getProperty("os.arch");
    if (s1 != null) {
     File file = new File(new File(dirs[i], s1), s);
     if (file.exists())
      return file.getAbsolutePath();
    }
    File file1 = new File(dirs[i], s);
    if (file1.exists())
     return file1.getAbsolutePath();
   }

   return null;
  }

  private static AccessControlContext getContext(File afile[])
          throws IOException {
   PathPermissions pathpermissions = new PathPermissions(afile);
   ProtectionDomain protectiondomain = new ProtectionDomain(
           new CodeSource(pathpermissions.getCodeBase(),
                   (java.security.cert.Certificate[]) null),
           pathpermissions);
   AccessControlContext accesscontrolcontext = new AccessControlContext(
           new ProtectionDomain[] { protectiondomain });
   return accesscontrolcontext;
  }

  private File dirs[];

  public ExtClassLoader(File afile[]) throws IOException {
   super(getExtURLs(afile), null, Launcher.factory);
   dirs = afile;
  }
 }

 private static class Factory implements URLStreamHandlerFactory {

  public URLStreamHandler createURLStreamHandler(String s) {
   String s1 = (new StringBuilder()).append(PREFIX).append(".")
           .append(s).append(".Handler").toString();
   try {
    Class class1 = Class.forName(s1);
    return (URLStreamHandler) class1.newInstance();
   } catch (ClassNotFoundException classnotfoundexception) {
    classnotfoundexception.printStackTrace();
   } catch (InstantiationException instantiationexception) {
    instantiationexception.printStackTrace();
   } catch (IllegalAccessException illegalaccessexception) {
    illegalaccessexception.printStackTrace();
   }
   throw new InternalError((new StringBuilder()).append(
           "could not load ").append(s).append(
           "system protocol handler").toString());
  }

  private static String PREFIX = "sun.net.www.protocol";

  private Factory() {
  }

 }

 public static Launcher getLauncher() {
  return launcher;
 }

 public Launcher() {
  ExtClassLoader extclassloader;
  try {
   extclassloader = ExtClassLoader.getExtClassLoader();
  } catch (IOException ioexception) {
   throw new InternalError("Could not create extension class loader");
  }
  try {
   loader = AppClassLoader.getAppClassLoader(extclassloader);
  } catch (IOException ioexception1) {
   throw new InternalError("Could not create application class loader");
  }
  Thread.currentThread().setContextClassLoader(loader);
  String s = System.getProperty("java.security.manager");
  if (s != null) {
   SecurityManager securitymanager = null;
   if ("".equals(s) || "default".equals(s))
    securitymanager = new SecurityManager();
   else
    try {
     securitymanager = (SecurityManager) loader.loadClass(s)
             .newInstance();
    } catch (IllegalAccessException illegalaccessexception) {
    } catch (InstantiationException instantiationexception) {
    } catch (ClassNotFoundException classnotfoundexception) {
    } catch (ClassCastException classcastexception) {
    }
   if (securitymanager != null)
    System.setSecurityManager(securitymanager);
   else
    throw new InternalError((new StringBuilder()).append(
            "Could not create SecurityManager: ").append(s)
            .toString());
  }
 }

 public ClassLoader getClassLoader() {
  return loader;
 }

 public static URLClassPath getBootstrapClassPath() {
  String s = (String) AccessController
          .doPrivileged(new GetPropertyAction("sun.boot.class.path"));
  URL aurl[];
  if (s != null) {
   String s1 = s;
   aurl = (URL[]) (URL[]) AccessController
           .doPrivileged(new PrivilegedAction(s1) {

            public Object run() {
             return Launcher.pathToURLs(Launcher
                     .getClassPath(path));
            }

            final String val$path;

            {
             path = s;
             super();
            }
           });
  } else {
   aurl = new URL[0];
  }
  return new URLClassPath(aurl, factory);
 }

 private static URL[] pathToURLs(File afile[]) {
  URL aurl[] = new URL[afile.length];
  for (int i = 0; i < afile.length; i++)
   aurl[i] = getFileURL(afile[i]);

  return aurl;
 }

 private static File[] getClassPath(String s) {
  File afile[];
  if (s != null) {
   int i = 0;
   int j = 1;
   boolean flag = false;
   int k;
   for (int i1 = 0; (k = s.indexOf(File.pathSeparator, i1)) != -1; i1 = k + 1)
    j++;

   afile = new File[j];
   int l;
   int j1;
   for (j1 = l = 0; (l = s.indexOf(File.pathSeparator, j1)) != -1; j1 = l + 1)
    if (l - j1 > 0)
     afile[i++] = new File(s.substring(j1, l));
    else
     afile[i++] = new File(".");

   if (j1 < s.length())
    afile[i++] = new File(s.substring(j1));
   else
    afile[i++] = new File(".");
   if (i != j) {
    File afile1[] = new File[i];
    System.arraycopy(afile, 0, afile1, 0, i);
    afile = afile1;
   }
  } else {
   afile = new File[0];
  }
  return afile;
 }

 static URL getFileURL(File file) {
  try {
   file = file.getCanonicalFile();
  } catch (IOException ioexception) {
  }
  try {
   return ParseUtil.fileToEncodedURL(file);
  } catch (MalformedURLException malformedurlexception) {
   throw new InternalError();
  }
 }

 private static URLStreamHandlerFactory factory = new Factory();

 private static Launcher launcher = new Launcher();

 private ClassLoader loader;

 private static URLStreamHandler fileHandler;

}