Java类加载器和双亲委派机制

类加载是Java如此流行的一个重要因素，是一个Java程序的起点，是万物的起源。

Java类加载的简单介绍

Java中的类加载大体分为四类：启动类加载器（Bootstrap ClassLoader）扩展类加载器（Extension ClassLoader）应用程序类加载器（Application ClassLoader）用户自定义类加载器（User ClassLoader）

启动类加载器：

负责加载JDK目录中\lib文件夹中的类，或者被-Xbootclasspath参数指定的路径下的可识别类。整个Java系统中很多基本组件都是有启动类加载器加载的，就连扩展类加载器和应用程序类加载器都是通过它加载的。在一个Java程序运行时，首先启动JVM，之后马上就诞生了启动类加载器，然后启动类加载器加载剩下两个系统加载器，之后这两个加载器再加载他们应该加载的类。

扩展类加载器：

负责加载JDK目录中\lib\ext文件夹中的类，或者被java.ext.dirs系统变量所指定的路径中的类库。这个类加载器的作用是用来与启动类加载器合作加载系统组件的。

应用程序类加载器：

负责加载ClassPath路径下的类，可以通过getSystemClassLoader()获取。如果没有自己定义类加载，我们编写的Java类都将被这个类加载器加载。是程序中的默认类加载。

用户自定义类加载器：

用户自己编写的类加载器，可以通过覆盖findClass()方法去进行加载类。

Java类与类加载的关系

Java的类与类加载是息息相关的，只有一个Java类全限定名并不能确定唯一的Java类。Java类只有与类加载一起才能确定一个唯一的类对象。

比如有一个com.test.T1类，然后我们在程序中自定义两个类加载，通过两个类加载器加载的两个com.test.T1类是不同的。一个程序中会有两个T1类对象。

当类加载器加载类时，会在类加载的名称空间中标识该类名称，以保证类加载器和类全名共同确定一个类对象。

双亲委派机制

如上图箭头所示，除了启动类加载器，每个类加载器都有一个父加载器。构成了一个类加载器结构系统。这个系统就是用来完成双亲委派机制的。

观察loadClass源码可以明白，一个类加载器加载一个类时，首先会把加载动作委派给他的父加载器，如果父加载器无法完成这个加载动作时才由该类加载器进行加载。由于类加载器会向上传递加载请求，所以一个类加载时，首先尝试加载它的肯定是启动类加载器（逐级向上传递请求，直到启动类加载器，它没有父加载器），之后根据是否能加载的结果逐级让子类加载器尝试加载，直到加载成功。

比如我们自己写了一个com.test.T1类，假设我们没有自定义类加载器，那么这个类会由应用程序类加载器加载。应用程序类加载器加载时先把加载任务委派给扩展类加载器（父加载器），然后扩展类加载器再把加载任务委托给启动类加载器（父加载器），启动类加载器没有父加载器。于是它自己尝试加载，结果发现T1类并不在自己的记载类路径之中，于是告诉扩展类加载器（子加载器）自己无法加载该类。这时扩展类只好自己加载这个类，结果发现也无法加载该类，于是它也告诉应用程序类加载器这个消息，这时应用程序类加载器自己进行T1类的加载动作，加载成功。

可以把每个类加载都想成一个大懒汉，每次让他办事时他都让爸爸代办。没想到爸爸也是个大懒汉，于是爸爸也让他的爸爸代办。这是到了爷爷那里，爷爷也很懒，但是他没有爸爸了，于是只能一边抱怨一边干，然后发现自己做不了，又骂骂咧咧的把活儿交给了自己的儿子，然后爸爸开始干活，发现自己也不能完成这个任务，于是他也是骂骂咧咧的把活交给了儿子，儿子挨了一顿骂，然后开始干活，经过了1小时的苦干，这个活儿终于完事了。

双亲委派机制的存在意义

双亲委派是Java语言的一大创新。表明看起来，由于双亲委派机制的存在，类加载器的数量增多了不少，增加了程序的复杂性。不过存在既有道理。双亲委派机制让Java类体系变得稳定，有层次性能。特定的类由特定的类加载器加载，每次加载都委托父类的过程让类对象在内存中的数量保持为一个，让同类名的类无法被替换。

如果没有双亲委派机制，只有一个类加载器，我们自己写一个java.lang.Object类，也可以被加载，结果就是内存中有两个Object类，引用的时候会造成安全的问题。而且一些核心的类可能会被替换，导致重大的安全问题。

有了双亲委派机制，我们自己写的java.lang.Object类在加载时会被加载器委托给父加载器，在某一个父加载器中发现内存中已经存在了java.lang.Object类，那么将不会进行加载，这样就保证了特定的类只能有一个在内存中。

不要破坏双亲委派机制

双亲委派机制不是强制性的，所以我们不经意的编码可能会对它造成破坏。如何让我们自己编写的类加载器安全的融入双亲委派机制呢？

public abstract class ClassLoader {
    ...
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }
    protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            //判断该类是否存在
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                ...
                try {
                    //如果存在父加载器就委托给父加载器
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                    //如果不存在父加载器就委托给启动类加载器
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    //捕捉父类发出的 无法加载该类 的异常
                }

                if (c == null) {
                    ...
                    //父类无法加载类，有该类加载器本身进行加载
                    c = findClass(name);
                    // do some stats
                    ...
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }
    ...
}

loadClass()方法是一个类加载的主要方法，从代码中我们可以看出该类加载器进行类加载的操作集中在findClass()方法中，loadClass()方法其余的代码都是在维护双亲委派机制，所以我们在实现自己的类加载器时只需重新findClass()方法即可，让loadClass()方法保持原样以便双亲委派机制的正确运行。