Launcher类源码分析

JDK开源：http://openjdk.java.net/

Launcher：

private static URLStreamHandlerFactory factory = new Launcher.Factory();
private static Launcher launcher = new Launcher();
private static String bootClassPath = System.getProperty("sun.boot.class.path");
private ClassLoader loader;
private static URLStreamHandler fileHandler;

public static Launcher getLauncher() {
   return launcher;
}

public Launcher() {
   //创建一个扩展类加载器
   Launcher.ExtClassLoader var1;
   try {
      //这里是去创建扩展类加载器，返回扩展类加载器的实例
      var1 = Launcher.ExtClassLoader.getExtClassLoader();
   } catch (IOException var10) {
      throw new InternalError("Could not create extension class loader", var10);
   }

   try {
      //这里是去创建系统类加载器的实例，这里我们可以看到，getAppClassLoader(var1)中的参数var1是
      //扩展类加载器get得到的结果，最终作为参数传递到getAppClassLoader中。
      //并且赋给了loader，而loader又是Launcher类的一个私有成员变量。
      //而且这句话也说明了， 扩展类加载器是系统类加载器的双亲！！！
      this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
   } catch (IOException var9) {
      throw new InternalError("Could not create application class loader", var9);
   }

   //Also set the conext class loader for the primordial thread
   //还为原始线程设置conext(上下文)类加载器
   Thread.currentThread().setContextClassLoader(this.loader);
   //Finally,install a security manager if requested
   //最终，如果需要，请安装安全管理器
   String var2 = System.getProperty("java.security.manager");
   if (var2 != null) {
      SecurityManager var3 = null;
      if (!"".equals(var2) && !"default".equals(var2)) {
         try {
            var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
         } catch (IllegalAccessException var5) {
            ;
         } catch (InstantiationException var6) {
            ;
         } catch (ClassNotFoundException var7) {
            ;
         } catch (ClassCastException var8) {
            ;
         }
      } else {
         var3 = new SecurityManager();
      }
      if (var3 == null) {
         throw new InternalError("Could not create SecurityManager: " + var2);
      }
      System.setSecurityManager(var3);
   }
}
//调用这个方法就是返回loader(App),而 ExtClassLoader会通过getParent得到！
public ClassLoader getClassLoader() {
   return this.loader;
}

ExtClassLoader：

//这里ExtClassLoader继承了URLClassLoader，URLClassLoader又继承了SecureClassLoader，
//SecureClassLoader又继承了ClassLoader
static class ExtClassLoader extends URLClassLoader， {
   /*
   	create an ExClassLoader. The ExtClassLoader is created within a context that 
   	limits which files it can read
   	创建一扩展类加载器，ExtClassLoader是在以下上下文中创建的限制它可以读取哪些文件
   */
   public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
      final File[] var0 = getExtDirs(); //就是返回扩展类加载器所加载的那几个目录路径

      try {
         //AccessController.doPrivilege主要是做一个权限的校验
         return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction<Launcher.ExtClassLoader>() {
            public Launcher.ExtClassLoader run() throws IOException {
               int var1 = var0.length;

               for(int var2 = 0; var2 < var1; ++var2) {
                  MetaIndex.registerDirectory(var0[var2]);
               }
					//最终返回一个ExtClassLoader，谁调用了，返回给谁！其实就是Launcher里面的
               //var1 = Launcher.ExtClassLoader.getExtClassLoader();
               return new Launcher.ExtClassLoader(var0); 
            }
         });
      } catch (PrivilegedActionException var2) {
         throw (IOException)var2.getException();
      }
   }

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

   public ExtClassLoader(File[] var1) throws IOException {
      super(getExtURLs(var1), (ClassLoader)null, Launcher.factory);
      SharedSecrets.getJavaNetAccess().getURLClassPath(this).initLookupCache(this);
   }

   //就是返回扩展类加载器所加载的那几个目录路径
   private static File[] getExtDirs() {
      //这个其实就是得到扩展类加载器所加载的那几个特定的目录路径
      String var0 = System.getProperty("java.ext.dirs");
      File[] var1;
      if (var0 != null) {
         //这里对多个路径进行分割
         StringTokenizer var2 = new StringTokenizer(var0, File.pathSeparator);
         int var3 = var2.countTokens(); //得到数目(几个路径)
         var1 = new File[var3]; //最终放在var1这个数组中

         for(int var4 = 0; var4 < var3; ++var4) {
            var1[var4] = new File(var2.nextToken());
         }
      } else {  //如果为空，就新new一个，返回回去
         var1 = new File[0];
      }

      return var1;
   }

   private static URL[] getExtURLs(File[] var0) throws IOException {
      Vector var1 = new Vector();

      for(int var2 = 0; var2 < var0.length; ++var2) {
         String[] var3 = var0[var2].list();
         if (var3 != null) {
            for(int var4 = 0; var4 < var3.length; ++var4) {
               if (!var3[var4].equals("meta-index")) {
                  File var5 = new File(var0[var2], var3[var4]);
                  var1.add(Launcher.getFileURL(var5));
               }
            }
         }
      }

      URL[] var6 = new URL[var1.size()];
      var1.copyInto(var6);
      return var6;
   }

   public String findLibrary(String var1) {
      var1 = System.mapLibraryName(var1);
      URL[] var2 = super.getURLs();
      File var3 = null;

      for(int var4 = 0; var4 < var2.length; ++var4) {
         URI var5;
         try {
            var5 = var2[var4].toURI();
         } catch (URISyntaxException var9) {
            continue;
         }

         File var6 = (new File(var5)).getParentFile();
         if (var6 != null && !var6.equals(var3)) {
            String var7 = VM.getSavedProperty("os.arch");
            File var8;
            if (var7 != null) {
               var8 = new File(new File(var6, var7), var1);
               if (var8.exists()) {
                  return var8.getAbsolutePath();
               }
            }

            var8 = new File(var6, var1);
            if (var8.exists()) {
               return var8.getAbsolutePath();
            }
         }

         var3 = var6;
      }

      return null;
   }

   private static AccessControlContext getContext(File[] var0) throws IOException {
      PathPermissions var1 = new PathPermissions(var0);
      ProtectionDomain var2 = new ProtectionDomain(new CodeSource(var1.getCodeBase(), (Certificate[])null), var1);
      AccessControlContext var3 = new AccessControlContext(new ProtectionDomain[]{var2});
      return var3;
   }

   static {
      ClassLoader.registerAsParallelCapable();
   }
}

AppClassLoader：

//The class loader used for loading from java.class.path. runs in a restricted security
//context
//用于从java.class.path加载的类加载器。在受限制的安全上下文中运行
static class AppClassLoader extends URLClassLoader {
   final URLClassPath ucp = SharedSecrets.getJavaNetAccess().getURLClassPath(this);

   public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
      //和extClassLoader差不多，这里是获取系统类加载器所加载多个目录
      final String var1 = System.getProperty("java.class.path");
      final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);
      return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
         public Launcher.AppClassLoader run() {
            URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);
            //这里调用下面的AppClassLoader var0是扩展类加载器！
            return new Launcher.AppClassLoader(var1x, var0);
         }
      });
   }

   //这里的var2参数，就是扩展类加载器，
   AppClassLoader(URL[] var1, ClassLoader var2) {
      super(var1, var2, Launcher.factory);
      this.ucp.initLookupCache(this);
   }

   public Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
      int var3 = var1.lastIndexOf(46);
      if (var3 != -1) {
         SecurityManager var4 = System.getSecurityManager();
         if (var4 != null) {
            var4.checkPackageAccess(var1.substring(0, var3));
         }
      }

      if (this.ucp.knownToNotExist(var1)) {
         Class var5 = this.findLoadedClass(var1);
         if (var5 != null) {
            if (var2) {
               this.resolveClass(var5);
            }

            return var5;
         } else {
            throw new ClassNotFoundException(var1);
         }
      } else {
         return super.loadClass(var1, var2);
      }
   }

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

   private void appendToClassPathForInstrumentation(String var1) {
      assert Thread.holdsLock(this);

      super.addURL(Launcher.getFileURL(new File(var1)));
   }

   private static AccessControlContext getContext(File[] var0) throws MalformedURLException {
      PathPermissions var1 = new PathPermissions(var0);
      ProtectionDomain var2 = new ProtectionDomain(new CodeSource(var1.getCodeBase(), (Certificate[])null), var1);
      AccessControlContext var3 = new AccessControlContext(new ProtectionDomain[]{var2});
      return var3;
   }

   //这里是将其注册为可以并行加载的！
   static {
      ClassLoader.registerAsParallelCapable();
   }
}

ClassLoader中初始化系统类加载器：

private static synchronized void initSystemClassLoader() {
   if (!sclSet) {
      if (scl != null)
         throw new IllegalStateException("recursive invocation");
      //得到创建的类加载器实例（其实系统类加载器，是否是扩展类加载器可以通过getParent去判别，即使用：
      //new SystemClassLoaderAction(scl)去判断）
      sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
      if (l != null) {
         Throwable oops = null;
         scl = l.getClassLoader();  //得到系统类加载器
         try {
            scl = AccessController.doPrivileged(
               //就是为了处理是：scl最终返回的是用户自定义系统类加载器还是默认的AppClassLoader
               new SystemClassLoaderAction(scl));
         } catch (PrivilegedActionException pae) {
            oops = pae.getCause();
            if (oops instanceof InvocationTargetException) {
               oops = oops.getCause();
            }
         }
         //异常处理
         if (oops != null) {
            if (oops instanceof Error) {
               throw (Error) oops;
            } else {
               // wrap the exception
               throw new Error(oops);
            }
         }
      }
      sclSet = true;
   }
}

class SystemClassLoaderAction
    implements PrivilegedExceptionAction<ClassLoader> {
    private ClassLoader parent;
	 //上面调用这个实例时，将scl(系统类加载器传过来)
    SystemClassLoaderAction(ClassLoader parent) {
        this.parent = parent;
    }

    /**
    		★★★比较重要要的一段！★★★
    */
    public ClassLoader run() throws Exception {
        //自定义系统类加载器的系统属性
        String cls = System.getProperty("java.system.class.loader");
        //如果为null，说明我们没有设置前面这一句属性，
        //说明系统类加载器就是默认的AppClassLoader
        if (cls == null) { 
            return parent;
        }

        Constructor<?> ctor = Class.forName(cls, true, parent)
            .getDeclaredConstructor(new Class<?>[] { ClassLoader.class });
        ClassLoader sys = (ClassLoader) ctor.newInstance(
            //这句代码也就说明为什么自定义系统类加载器的父亲是AppClassLoader
            new Object[] { parent }); 
        //sys 也就是用户自定义的系统类加载器，将其放进上下文类加载器
        Thread.currentThread().setContextClassLoader(sys);
        return sys;
    }
}