ClassLoader类加载器

关于ClassLoader原理网上简介颇多，但是讲的好的，能让人简而易懂的理解的，个人觉得以下这个片博客写的不错。

java虚拟机原理图解 5. JVM类加载器机制与类加载过程

为了理解本文，我从代码角度来分析JVM加载机制和类加载过程

首先：

　　BootStrapClassLoader----引导类加载器---C++编写，封装入JVM中

　　ExtClassLoader----------扩展类加载器---Launcher内部类

　　AppClassLoader----------应用类加载器/系统类加载器---Launcher内部类

当我们在IJ或者eclipse中run一个带main方法的类时或者在linux下java batchmain时，

在run之前，我们的java虚拟机是关闭的状态。run后，虚拟机开启，BootStrapClassLoader会加载{JAVA_HOME}/jre/lib下的jar包，

其中有一个rt.jar的包中，我们会找到一个sun.misc.Launcher类，既然BootStrapClassLoader加载rt.jar必然会加载Launcher，

这里我贴了源代码：

 

package sun.misc;

import ...

public class Launcher {
    private static URLStreamHandlerFactory factory = new Launcher.Factory();
　　//我们可以看出这个单例模式，私有化launcher，当BootStrap加载Launcher时，自动创建Launcher的实例
    private static Launcher launcher = new Launcher();
    private static String bootClassPath = System.getProperty("sun.boot.class.path");
    private ClassLoader loader;
    private static URLStreamHandler fileHandler;
　　//单例模式提供的public get方法
    public static Launcher getLauncher() {
        return launcher;
    }
　　//构造方法，会实例化内部类ExtClassLoader和AppClassLoader
    public Launcher() {
        Launcher.ExtClassLoader var1;
        try {
　　　　　　　　//实例化ExtClassLoader
            var1 = Launcher.ExtClassLoader.getExtClassLoader();
        } catch (IOException var10) {
            throw new InternalError("Could not create extension class loader", var10);
        }

        try {
　　　　　　　　//实例化AppClassLoader
            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();
            System.setSecurityManager(var3);
        }

    }

 

AppClassLoader and ExtClassLoader拥有相同的以下继承关系:

AppClassLoader extends URLClassLoader extends SecureClassLoader extends ClassLoader

ExtClassLoader extends URLClassLoader extends SecureClassLoader extends ClassLoader

ClassLoader是个抽象类，但是有构造方法，如下

//代码我以略掉大部分
public abstract class ClassLoader {
    private final ClassLoader parent;

    private ClassLoader(Void unused, ClassLoader parent) {
        this.parent = parent;
     }
}

AppClassLoader和ExtClassLoader实例化这个部分我也贴出代码:

 

static class AppClassLoader extends URLClassLoader {
        final URLClassPath ucp = SharedSecrets.getJavaNetAccess().getURLClassPath(this);

        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);
　　　　　　　　　　　　　　//此处返回的对象根据java多态性回调用Classloader抽象类构造方法，其parent传值为var0，即ExtClassLoader
                    return new Launcher.AppClassLoader(var1x, var0);
                }
            });
        }

        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);
            }
        }

static class ExtClassLoader extends URLClassLoader {
        public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
            final File[] var0 = getExtDirs();

            try {
                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]);
                        }
　　　　　　　　　　　　　　//此处返回的对象根据java多态性回调用Classloader抽象类构造方法，其parent传值为null。
                        return new Launcher.ExtClassLoader(var0);
                    }
                });
            } catch (PrivilegedActionException var2) {
                throw (IOException)var2.getException();
            }
        }

 至此JVM类加载器初始化完毕。然后loader.loadClass();

此时我们根据类加载规则，去加载main类，如果发现有main()方法，就开始直接执行，直到exit。

我们需要注意的是，类加载器加载一个类时，并不是去读代码看看那些类需要加载，这里涉及到最重要的东西那就是：

Import，因为我们需要的类都是引入进来的，引入包直接加载就好了。

 

而setContextClassLoader可以打破双亲加载机制。典型应用---tomcat启动类BootStrap定义了三个自定义加载器,
catalinaClassLoader  
commonClassLoader 
sharedClassLoader
......