Java中的类加载ClassLoader

一 概述

编译器会将java源文件编译成以字节码形式保存的class文件，而ClassLoader将字节码转换JVM中的Class<T>对象，我们以Byte数组的形式将获取的字节码传递过来，使得JVM利用Class<?>对象实例化?(泛型)具体所表示类的对象。

类的生命周期：

二 类加载的种类

1.Bootstrap ClassLoader：这个类加载器使用C++语言实现，是虚拟机的一部分，该加载器负责将JAVA_HOME/lib中的类库加载到内存中（如rt.jar）。该类加载器涉及虚拟机的本地实现，所以无法直接获取该类加载的引用。

2.标准扩展类加载器：由sun的ExtClassLoader(sum.misc.Launcher中的静态类ExtClassLoader)实现，该类加载器实现了JAVA_HOME/lib/ext中的类库或者由系统变量java.ext.dir指定位置中的类库加载到内存中。所以我们可以将自定义的jar文件放入特定目录下，通过该加载器进行加载。

3. 应用程序加载器：由sun的AppClassLoader(sum.misc.Launcher中的静态类AppClassLoader)实现的。它负责将系统类路径（CLASSPATH）中指定的类库加载到内存中。

4.自定类加载器：customClassLoader。

自定义加载器的实现过程中重要的两个方法：

    //寻找目标类
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }
    //JDK默认实现的方法
    protected final Class<?> defineClass(String name, byte[] b, int off, int len)
        throws ClassFormatError
    {
        return defineClass(name, b, off, len, null);
    }

                           

三 类加载的过程中的双亲委派机制

阅读源码可知，检测是否加载某类时，在java.lang.ClassLoader的loadClass()方法中，先检查是否已经被加载过，若没有加载则调用父类加载器的loadClass()方法，若父加载器为空则默认使用启动类加载器作为加载器。如果加载失败，则抛出ClassNotFoundException异常后，再调用自己的findClass()方法进行加载。

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        //这里会涉及到多个线程使用同一个ClassLoader去加载同一个类，所以为该类添加同步锁
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            /*先从CustomClassLoader开始检查某类是否被加载，如没有然后到parent ClassLoader(AppClassLoader)
             *中检查，如果也没有再到parent ClassLoader(ExtClassLoader)中检查。如果这三个ClassLoader中都没有
             * 加载该类，就会到BootStrapClassLoader(C++编写并不是其他加载器的父类)中去检查。
            * */
            /*
            * CustomClassLoader
            * */
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        /*
                        * 使用父加载器：AppClassLoader->ExtClassLoader
                        * */
                        c = parent.loadClass(name, false);
                    } else {
                        //BootStrapClassLoader
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }
                /*
                *BootStrapClassLoader->ExtClassLoader,AppClassLoader,CustomClassLoader
                * 按需求使用各自实现代findClass(name)方法
                * 来加载在加载器中没有被加载到类
                * */

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

类加载时，某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。

注意：不同加载器之间的关系

• 启动类加载器，由C++实现，没有父类。

• 拓展类加载器(ExtClassLoader)，由Java语言实现，父类加载器为null

• 系统类加载器(AppClassLoader)，由Java语言实现，父类加载器为ExtClassLoader

• 自定义类加载器，父类加载器为AppClassLoader。

双亲委派机制是为了避免多份同样字节码被加载，造成内存中的数据重复。同时，Java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类java.lang.Object，它存在在rt.jar中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的Bootstrap ClassLoader进行加载，因此Object类在程序的各种类加载器环境中都是同一个类。相反，如果没有双亲委派模型而是由各个类加载器自行加载的话，如果用户编写了一个java.lang.Object的同名类并放在ClassPath中，那系统中将会出现多个不同的Object类，程序将混乱。因此，如果开发者尝试编写一个与rt.jar类库中重名的Java类，可以正常编译，但是永远无法被加载运行。