JavaSE知识点17java类加载器详解

1 什么是ClassLoader?

  • 1 大家都知道,当我们写好一个Java程序之后,不是管是CS还是BS应用,都是由若干个.class文件组织而成的一个完整的Java应用程序,当程序在运行时,即会调用该程序的一个入口函数来调用系统的相关功能,而这些功能都被封装在不同的class文件当中,所以经常要从这个class文件中要调用另外一个class文件中的方法,如果另外一个文件不存在,则会引发系统异常。
  • 2 而程序在启动的时候,并不会一次性加载程序所要用的所有class文件,而是根据程序的需要,通过Java的类加载机制(ClassLoader)来动态加载某个class文件到内存当中的,从而只有class文件被载入到了内存之后,才能被其它class所引用。所以ClassLoader就是用来动态加载class文件到内存当中用的。

2 Java提供的三个默认ClassLoader

  • 1 BootStrap ClassLoader:称为启动类加载器,是Java类加载层次中最顶层的类加载器,负责加载JDK中的核心类库,如:rt.jar、resources.jar、charsets.jar等,可通过查找sun.boot.class.path这个系统属性,得知该类加载器从哪些地方加载了相关的jar或class文件。
System.out.println(System.getProperty("sun.boot.class.path"));  

输出结果为:

C:\Program Files\Java\jdk1.6.0_22\jre\lib\resources.jar;
C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar;
C:\Program Files\Java\jdk1.6.0_22\jre\lib\sunrsasign.jar;
C:\Program Files\Java\jdk1.6.0_22\jre\lib\jsse.jar;
C:\Program Files\Java\jdk1.6.0_22\jre\lib\jce.jar;
C:\Program Files\Java\jdk1.6.0_22\jre\lib\charsets.jar;
C:\Program Files\Java\jdk1.6.0_22\jre\classes
  • 2 Extension ClassLoader:称为扩展类加载器,负责加载Java的扩展类库,默认加载JAVA_HOME/jre/lib/ext/目下的所有jar。
  • 3 App ClassLoader:称为系统类加载器,负责加载应用程序classpath目录下的所有jar和class文件。
  • 4 总结
    Extension ClassLoader和App ClassLoader也继承自java.lang.ClassLoader类,但是Bootstrap ClassLoader不继承自java.lang.ClassLoader类,因为它不是一个普通的Java类,底层由C++编写,已嵌入到了JVM内核当中,当JVM启动后,Bootstrap ClassLoader也随着启动,负责加载完核心类库后,并构造Extension ClassLoader和App ClassLoader类加载器。

3 ClassLoader加载类的原理

  • 1 原理简介
    1)ClassLoader使用的是双亲委托模型来搜索类的,每个ClassLoader实例都有一个父类加载器的引用(不是继承的关系,是一个包含的关系)。
    2)类加载器的包含关系如下:
    自定义类加载器————>系统类加载器————>扩展类加载器————>根加载器
    3)当一个自定义ClassLoader实例需要加载某个类时,先从自己的命名空间里查找是否已加载该类,如果已加载,则直接返回代表该类的Class对象的引用。
    4)如果没加载,才委托其父类加载器进行加载。其父类加载器命名空间没有在,则一层层向上委托,直到根加载器。然后由根加载器开始从上到下加载该类。一旦加载到则将这个找到的类生成一个类的定义,并将它加载到内存当中,最后返回这个类在内存中的Class实例对象的引用。
    5)如果所有加载器都没有加载到这个类时,则抛出ClassNotFoundException异常。
  • 2 为什么要使用双亲委托这种模型呢?
    1)这样可以避免重复加载,当父亲已经加载了该类的时候,就没有必要子ClassLoader再加载一次。
    2)考虑到安全因素,我们试想一下,如果不使用这种委托模式,那我们就可以随时使用自定义的String来动态替代java核心api中定义的类型,这样会存在非常大的安全隐患,而双亲委托的方式,就可以避免这种情况,因为String已经在启动时就被引导类加载器(Bootstrcp ClassLoader)加载,所以用户自定义的ClassLoader永远也无法加载一个自己写的String,除非你改变JDK中ClassLoader搜索类的默认算法。
  • 3 JVM在搜索类的时候,又是如何判定两个class是相同的呢?
    1)JVM在判定两个class是否相同时,不仅要判断两个类名是否相同,而且要判断是否由同一个类加载器实例加载的。只有两者同时满足的情况下,JVM才认为这两个class是相同的。就算两个class是同一份class字节码,如果被两个不同的ClassLoader实例所加载,JVM也会认为它们是两个不同class。
    2)比如网络上的一个Java类,javac编译之后生成字节码文件,同一个自定义类加载器的两个实例同时读取了这个字节码文件,并分别定义出了java.lang.Class实例来表示这个类,对于JVM来说,它们是两个不同的实例对象,但它们确实是同一份字节码文件,如果试图将这个Class实例生成具体的对象进行转换时,就会抛运行时异常java.lang.ClassCaseException,提示这是两个不同的类型。

4 定义自已的ClassLoader

  • 1 既然JVM已经提供了默认的类加载器,为什么还要定义自已的类加载器呢?
    因为Java中提供的默认ClassLoader,只加载指定目录下的jar和class,如果我们想加载其它位置的类或jar时,比如:我要加载网络上的一个class文件,通过动态加载到内存之后,要调用这个类中的方法实现我的业务逻辑。在这样的情况下,默认的ClassLoader就不能满足我们的需求了,所以需要定义自己的ClassLoader。
  • 2 定义自已的类加载器分为两步:
    1)继承java.lang.ClassLoader
    2)重写父类的findClass方法
  • 3 父类有那么多方法,为什么偏偏只重写findClass方法?
    因为JDK已经在loadClass方法中帮我们实现了ClassLoader搜索类的算法,当在loadClass方法中搜索不到类时,loadClass方法就会调用findClass方法来搜索类,所以我们只需重写该方法即可。
  • 4 代码举例
package lwlstudy.test.classloader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class MyClassLoader extends ClassLoader {

    private String classPath;

    public MyClassLoader(String classPath) {
        this.classPath = classPath;
    }

    public String getClassPath() {
        return classPath;
    }

    public void setClassPath(String classPath) {
        this.classPath = classPath;
    }

    public MyClassLoader(ClassLoader parent) {
        super(parent);
    }

    @Override
    protected Class findClass(String className) throws ClassNotFoundException {
        byte[] data = this.getData(className);
        if (data == null) {
            throw new ClassNotFoundException();
        } else {
            return defineClass(className, data, 0, data.length);
        }
    }

    private byte[] getData(String className) {

        String path = classPath + File.separatorChar + className.replace('.', File.separatorChar) + ".class";
        InputStream is = null;
        ByteArrayOutputStream stream = null;
        try {
            is = new FileInputStream(new File(path));
            stream = new ByteArrayOutputStream();
            byte[] buffer = new byte[2048];
            int num = 0;
            while ((num = is.read(buffer)) != -1) {
                stream.write(buffer, 0, num);
            }
            return stream.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
                stream.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
        }

        return null;
    }

    public static void main(String[] args) throws Exception {

        MyClassLoader mcl1 = new MyClassLoader("W:\\zz");
        Class clazz = mcl1.loadClass("lwlstudy.test.classloader.Dog");
        Object obj = clazz.newInstance();
        Object obj1 = clazz.newInstance();
        System.out.println(obj.getClass().equals(obj1.getClass()));

        MyClassLoader mcl2 = new MyClassLoader("W:\\zz");
        Class clazz2 = mcl2.loadClass("lwlstudy.test.classloader.Dog");
        Object obj2 = clazz2.newInstance();

        System.out.println(obj.getClass().equals(obj2.getClass()));
    }
}
```
输出结果为:
```java
true
false
```
原因参考:如何判定两个class是相同的呢?

你可能感兴趣的:(JavaSE知识点17java类加载器详解)