类加载器 ClassLoder详解

一、类加载器定义

从作用的角度来认识类加载器：(根据API文档)

1.类加载器是一个负责加载类的对象，而ClassLoader是一个抽象类。类加载器将xxx.class文件加载到JVM，生成xxx的Class对象。(Class详见反射 点击这里)

2.类加载器被安全管理器用来表示安全范围。

二、类加载器种类及工作原理

主要有三 ：

1.Bootstrap Loader(引导加载器)：负责加载%JAVA_HOME%/jre/lib下的核心jar

2.Extended Loader(扩展加载器)：负责加载%JAVA_HOME%/jre/lib/ext下的扩展jar

3.AppClass Loader(应用加载器)：负责加载该应用程序CLASSPATH下的jar和.class文件

工作原理：

　　每一个类加载器都有一个与之关联的上级类加载器，类加载器加载器类时使用委托机制。当需要加载一个类时，它首先将该任务委托给上级加载器，如果上级加载器没能加载到，然后再自行加载，这是一个递归的过程。应用加载器的上级是扩展加载器，扩展加载器的上级是引导加载器，而引导加载无上级加载器。

三、类加载器的安全管理

　　JVM为每个类加载器维护了一个名字空间，每个名字空间只能加载一个同名的类，不同名字空间可加载同名的类。在JVM中，同一个名字空间下的类可以直接交互，不同则不可以。如果a加载器和b加载器都加载了A类，那么a加载器下的类要访问A类，那么一定是访问的a加载器下的A类。这样，通过类加载器就可以进行安全管理。

　　举个例子：我们自己写了一个类叫java.lang.String和类库里的String的全限定名一模一样。现在在代码中出现了String类，需要加载，过程如下。

　　　　>首先这个任务是应用加载器的，根据委托机制，应用加载器将任务委托给上级扩展加载器。

　　　　　　>扩展加载器接收到该任务，将任务委托给上级引导加载器。

　　　　　　　　>引导加载器加载在核心类库中寻找java.lang.String，找到了，加载，生成Class对象。

　　　　　　　　>引导加载器将结果返回给扩展加载器。

　　　　　　>扩展加载器将结果返回给应用加载器。

　　　　>应用加载器得到结果。

　　应用加载器的到的结果是引导加载器从核心类库中加载的java.lang.String 并没有加载到我们自己写的String。这样就保证了安全性。java其他很多类都依赖String 类，如果加载了我们自己写的String就会造成严重的问题。类加载器的委托机制就提供了很好的安全防护。

　　在例如：我们写了一个类叫java.lang.Hello，java核心类库中并不存在这个类，但它的所属的包结构却是java.lang，而同一个包下的类具有访问protected成员的权限，(protected详细解析 点击这里)这样就又会造成一些安全问题。分析一下类加载器加载Hello类的过程，按照上面的委托机制可以确定，引导、扩展加载器范围内并没有这个类，最后Hello是被应用加载器加载的，那么这个类是在应用加载器的名字空间下。开头已经给出，不同名字空间下的类不能直接交互，那么此处的java.lang.Hello并不能像核心类库的java.lang包下的类一样拥有protected的访问权限。类加载器的委托机制再一次提供了安全保护。

四、自定义类加载器

　　通过反射加载一个不存在的类

@Test
    public void funxx() throws ClassNotFoundException {
        Class.forName("xxx");
    }

　　异常栈:

　　aaarticlea/png;base64,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" alt="" />

　　loaderClass源码：

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

　　分析以上信息，可以发现，ClassLoader加载类是通过loadClass()方法完成的，其工作流程如下：

　　1.调用findLoadedClass()查看该类是否被加载过，如果没有，返回null

　　2.如果findLoadedClass()返回null，那么使用委托机制进行类加载。

　　3.如果getParent().loadClass() != null , 表明加载成功，否则调用本类的findClass()方法进行加载。

　　由此可见，我们自定义一个类加载器，只需要继承ClassLoader，并重写其findClass()方法即可。

　　下面是个人写的一个ClassLoader

package cn.edu;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class CustomizedClassLoader extends ClassLoader{

    private String classpath;                                                

    public CustomizedClassLoader() {

    }

    public CustomizedClassLoader(String classpath) {
        this.classpath = classpath;
    }

    //当loaderClass没有找到该类时，会自动调用此方法寻找类。
    @Override
    public  Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] data = this.getBytesData(name);                           //获取.class文件的字节数组
            if(data == null) {
                throw new ClassNotFoundException("找不到类：" + name);
            }
            return this.defineClass(name, data, 0, data.length);             //loaderClass继承的方法，该方法通过字节数组生成Class对象
        }catch(IOException e){
            throw new ClassNotFoundException("找不到类：" + name);
        }
    }

    //读取.class文件，返回字节数组，若读取到的内容为空，则返回null
    private byte[] getBytesData(String name) throws IOException{
        name = name.replace(".", "//") + ".class";                           //解析binary name，得到文件绝对路径
        File file = new File(classpath,name);
        byte[] res = this.readFile(file);
        if(res.length == 0) {                                                //字节数组为空，返回null
            return null;
        }
        return res;
    }

    //读取指定文件，返回字节数组,若找不到该文件，则IO异常
    private byte[] readFile(File file) throws IOException{
        FileReader reader = new FileReader(file);
        BufferedReader bufferedReader = new BufferedReader(reader);
        String str = null;
        String res = "";
        while( (str = bufferedReader.readLine()) != null) {
            res += str;
        }
        return res.getBytes();
    }
}

五、Tomcat的类加载器

　　Tomcat有两类类加载器，一类是服务器类加载器，用于加载${CATALINA_HOME}/lib目录下的jar，这些是web容器所依赖的jar。还有一类是应用类加载器，加载${CONTEXT_PATH}/WEB-INF下的lib和class目录，用于加载该应用所依赖的jar和class。这两种类加载器，不适用委托机制，在应用需要加载类时，首先由应用加载器加载，加载失败再由服务器加载器加载，并且class目录优先于lib目录。并且每一个应用都有一个对应的类加载器加载。所以在给项目导入jar时应该注意不能导入与服务器类库有冲突的jar。

　　　　本文个人编写，水平有限，如有错误，恳请指出，欢迎讨论分享。