Java类加载器

java.net.URLClassLoader -> java.security.SecureClassLoader -> java.lang.ClassLoader

//java.lang.ClassLoader.java
    // 双亲的定义
    private final ClassLoader parent;
    // 加载方法
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class c = findLoadedClass(name);
            //如果没有加载过，则进行加载
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    // 先检查双亲
                    if (parent != null) {  // 如果有双亲，则委派给双亲去加载
                        c = parent.loadClass(name, false);
                    } else { // 没有双亲才使用Bootstrap类加载器加载
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }
                // 如果父类加载器和启动类加载器都不能完成加载任务，才调用自身的加载功能
                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    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;
        }
    }

// java.loang.ClassLoader.java
    // 三个构造方法
    protected ClassLoader() {
        this(checkCreateClassLoader(), getSystemClassLoader());
    }
    protected ClassLoader(ClassLoader parent) {
        this(checkCreateClassLoader(), parent);
    }
    private ClassLoader(Void unused, ClassLoader parent) {
        this.parent = parent;
        ...
    }
    // 不指定parent时，默认的parent为系统(System)类加载器，即AppClassLoader
    public static ClassLoader getSystemClassLoader() {
        // 通过java.lang.ClassLoader.getSystemClassLoader()可以直接获取到系统类加载器，后面会通过代码进行测试
        ...
    }
==========================================================================================================
// sun.misc.Launcher.java
    private ClassLoader loader;
    // Launcher 的构造方法
    public Launcher() {
        // Create the extension class loader
        ClassLoader extcl;  // 这里定义了 extcl
        try {
            extcl = ExtClassLoader.getExtClassLoader(); // 调用了内部类ExtClassLoader的方法，生成了ExtClassLoader
        } catch (IOException e) {
            throw new InternalError("Could not create extension class loader");
        }
        // Now create the class loader to use to launch the application
        try {
           loader = AppClassLoader.getAppClassLoader(extcl);  // 调用了内部类的getAppClassLoader方法
        } catch (IOException e) {
            throw new InternalError("Could not create application class loader");
        }
        ...
    }
    // 内部类 AppClassLoader
    static class AppClassLoader extends URLClassLoader {
        // AppClassLoader 的构造方法，所以生成AppClassLoader时必须指定parent
        AppClassLoader(URL[] urls, ClassLoader parent) {
            // 在此设置了 AppClassLoader 的 parent
            super(urls, parent, factory);
        }
        // 内部类的方法
        public static ClassLoader getAppClassLoader(final ClassLoader extcl) throws IOException
        {
            final String s = System.getProperty("java.class.path");
            final File[] path = (s == null) ? new File[0] : getClassPath(s);
            return AccessController.doPrivileged( new PrivilegedAction<AppClassLoader>() {
                    public AppClassLoader run() {
                    URL[] urls = (s == null) ? new URL[0] : pathToURLs(path);
                    // 这里指定了 AppClassLoader 的parent为extcl
                    return new AppClassLoader(urls, extcl);  // 生成了AppClassLoader并且设置其parent为extcl
                }
            });
        }
    }
    // 内部类 ExtClassLoader
    static class ExtClassLoader extends URLClassLoader {
        // ExtClassLoader 的构造方法
        public ExtClassLoader(File[] dirs) throws IOException {
            // 调用URLClassLoader的构造方法 URLClassLoader(URL[] urls, ClassLoader parent, URLStreamHandlerFactory factory)
            // 直接把 ExtClassLoader 的 parent 设置为null
            super(getExtURLs(dirs), null, factory);
        }
    }

public class TestClassLoader {
    public static void main(String[] args) {
        try {
            System.out.println(ClassLoader.getSystemClassLoader());
            System.out.println(ClassLoader.getSystemClassLoader().getParent());
            System.out.println(ClassLoader.getSystemClassLoader().getParent().getParent());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class TestClassLoader {
    public static void main(String[] args) {
        try {
            // 通过Class.forName加载类
            Class loadedClass = Class.forName("com.test.classloader.TestClassLoader");
            // 查看被加载的类是被那个类加载器加载的
            System.out.println(loadedClass.getClassLoader());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}