源码解析Java类加载器

public Launcher() {
  Launcher.ExtClassLoader var1;
  try {
  	// 获取扩展类加载器
   var1 = Launcher.ExtClassLoader.getExtClassLoader(); 
  } catch (IOException var10) {
   throw new InternalError("Could not create extension class loader", var10);
  }

  try {
  	// 获取系统类加载器
   this.loader = Launcher.AppClassLoader.getAppClassLoader(var1); 
  } catch (IOException var9) {
   throw new InternalError("Could not create application class loader", var9);
  }
		// 此处是将系统类加载器设置为当前线程的上下文加载器
  Thread.currentThread().setContextClassLoader(this.loader); 
  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);
  }

 }

// 这是ExtClassLoader类内部的定义
private static volatile Launcher.ExtClassLoader instance;// 单例模式实例对象

public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
// 从这里可以看出，ExtClassLoader是一个由double-checking形成的懒汉式单例对象
   if (instance == null) { 
    Class var0 = Launcher.ExtClassLoader.class;
    synchronized(Launcher.ExtClassLoader.class) {
     if (instance == null) {
      instance = createExtClassLoader(); // 创建ExtClassLoader
     }
    }
   }

   return instance;
  }

// createExtClassLoader()方法
private static Launcher.ExtClassLoader createExtClassLoader() throws IOException {
   try {
    return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction<Launcher.ExtClassLoader>() {
     public Launcher.ExtClassLoader run() throws IOException {
      File[] var1 = Launcher.ExtClassLoader.getExtDirs();
      int var2 = var1.length;

      for(int var3 = 0; var3 < var2; ++var3) {
       MetaIndex.registerDirectory(var1[var3]);
      }

      return new Launcher.ExtClassLoader(var1); // 调用构造方法
     }
    });
   } catch (PrivilegedActionException var1) {
    throw (IOException)var1.getException();
   }
  }

// ExtClassLoader的构造方法
public ExtClassLoader(File[] var1) throws IOException {
			// 此处第二个参数需要格外注意！！，我们进入父类的构造方法查看该参数是什么
   super(getExtURLs(var1), (ClassLoader)null, Launcher.factory); 
   SharedSecrets.getJavaNetAccess().getURLClassPath(this).initLookupCache(this);
  }

// 父类URLClassLoader的构造方法
// 此处的第二个参数是父类构造器的引用，也就解释了为什么在调用获得ExtClassLoader的
public URLClassLoader(URL[] urls, ClassLoader parent, getParent()方法获取父类构造器为null
       URLStreamHandlerFactory factory) {
  super(parent);
  // this is to make the stack depth consistent with 1.1
  SecurityManager security = System.getSecurityManager();
  if (security != null) {
   security.checkCreateClassLoader();
  }
  acc = AccessController.getContext();
  ucp = new URLClassPath(urls, factory, acc);
 }

public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
   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);
     return new Launcher.AppClassLoader(var1x, var0); // 与扩展类加载器不同的是，系统类加载器并不是单例模式的
    }
   });
  }
// AppClassLoader的构造方法
AppClassLoader(URL[] var1, ClassLoader var2) { 
 // 这里的var2 对应上述getAppClassLoader()方法中的var0，而var0对应的就是Launcher的构造方法中获取到的ExtClassLoader
 // 在ExtClassLoader源码的分析中，我们知道这个var2代表的就是父类构造器，所以此处就是将AppClassLoader的父类设置为ExtClassLoader
   super(var1, var2, Launcher.factory);
   this.ucp.initLookupCache(this);
  }

public Class<?> loadClass(String name) throws ClassNotFoundException {
		// loadClass调用重载含有两个参数的loadClass，其中第二个参数表示在加载时是否解析，默认为false
  return loadClass(name, false); 
 }
// 含有两个参数的重载loadClass方法
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException{// resolve:true->加载class的同时进行解析操作
  synchronized (getClassLoadingLock(name)) {// 同步操作，保证只能加载一次
   // 首先在缓存中判断是否已经加载同名的类
   Class<?> c = findLoadedClass(name);
   if (c == null) {
    long t0 = System.nanoTime();
    // 此处就是双亲委派机制的具体实现，其实就是让父类加载器先去加载。
    try {
     // 获取当前类加载器的父类加载器
     if (parent != null) {
      // 如果存在父类加载器，则调用父类加载器的loadClass进行加载(双亲委派)
      c = parent.loadClass(name, false);
     } else { 
     		 // parent == null:父类加载器是引导类加载器
      c = findBootstrapClassOrNull(name);
     }
    } catch (ClassNotFoundException e) {
     // ClassNotFoundException thrown if class not found
     // from the non-null parent class loader
    }
				// 当前类加载器的父类加载器未加载此类 or 当前类加载器未加载此类
    if (c == null) { 
     // If still not found, then invoke findClass in order
     // to find the class.
     long t1 = System.nanoTime();
     // 调用当前类加载器的findClass()
     c = findClass(name);

     // this is the defining class loader; record the stats
     sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
     sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
     sun.misc.PerfCounter.getFindClasses().increment();
    }
   }
   if (resolve) {// 是否进行解析操作
    resolveClass(c);
   }
   return c;
  }
 }

//在ClassLoader中的findClass()方法
rotected Class<?> findClass(String name) throws ClassNotFoundException {
  throw new ClassNotFoundException(name);
 }

protected Class<?> findClass(final String name)
  throws ClassNotFoundException
 {
  final Class<?> result;
  try {
   result = AccessController.doPrivileged(
    new PrivilegedExceptionAction<Class<?>>() {
     public Class<?> run() throws ClassNotFoundException {
      String path = name.replace('.', '/').concat(".class");// 类名路径字符串格式替换
      Resource res = ucp.getResource(path, false);// 获得class源文件
      if (res != null) {
       try {
       	// 调用defineClass()方法获得要加载的类对应的Class对象，
       	// defineClass()的作用就是根据给定的class源文件返回一个对应的Class对象
        return defineClass(name, res);
       } catch (IOException e) {
        throw new ClassNotFoundException(name, e);
       }
      } else {
       return null;
      }
     }
    }, acc);
  } catch (java.security.PrivilegedActionException pae) {
   throw (ClassNotFoundException) pae.getException();
  }
  if (result == null) {
   throw new ClassNotFoundException(name);
  }
  return result;
 }