详解 Java ClassLoader

最新推荐文章于 2024-09-04 22:34:45 发布

不能说的秘密go

最新推荐文章于 2024-09-04 22:34:45 发布

阅读量1.2k

点赞数

分类专栏： java基础 JVM 文章标签： java classloader 虚拟机编译器

本文链接：https://blog.csdn.net/canot/article/details/51031143

版权

java基础同时被 2 个专栏收录

56 篇文章 3 订阅

订阅专栏

JVM

10 篇文章 0 订阅

订阅专栏

1.类加载器基本概念

　　顾名思义，类加载器（class loader）用来加载 Java 类到 Java 虚拟机中。一般来说，Java 虚拟机使用 Java 类的方式如下：Java 源程序（.java 文件）在经过 Java 编译器编译之后就被转换成 Java 字节代码（.class 文件）。类加载器负责读取 Java 字节代码，并转换成 java.lang.Class 类的一个实例。每个这样的实例用来表示一个 Java 类。通过此实例的 newInstance()方法就可以创建出该类的一个对象。实际的情况可能更加复杂，比如 Java 字节代码可能是通过工具动态生成的，也可能是通过网络下载的。

基本上所有的类加载器都是 java.lang.ClassLoader 类的一个实例。下面详细介绍这个 Java 类:

java.lang.ClassLoader 类的基本职责就是根据一个指定的类的名称，找到或者生成其对应的字节代码，然后从这些字节代码中定义出一个 Java 类，即 java.lang.Class 类的一个实例。除此之外，ClassLoader 还负责加载 Java 应用所需的资源，如图像文件和配置文件等。为了完成加载类的这个职责，ClassLoader 提供了一系列如下的方法:

    getParent() 返回该类加载器的父类加载器。

　　 loadClass(String name) 加载名称为 name 的类，返回的结果是 java.lang.Class 类的实例。

　　findClass(String name) 查找名称为 name 的类，返回的结果是 java.lang.Class 类的实例。

　　findLoadedClass(String name) 查找名称为 name 的已经被加载过的类，返回的结果是 java.lang.Class 类的实例。

　　defineClass(String name, byte[] b, int off, int len) 把字节数组 b 中的内容转换成 Java 类，返回的结果是 java.lang.Class 类的实例。这个方法被声明为 final 的。

　　resolveClass(Class<?> c) 链接指定的 Java 类。

如上就是class loader的概念和作用。

2.类加载器的实现

当JVM（Java虚拟机）启动时，会形成由三个类加载器组成的初始类加载器层次结构：

       bootstrap classloader
                |
       extension classloader
                |
       system classloader

bootstrap classloader －引导（也称为原始）类加载器，它负责加载Java的核心类。在Sun的JVM中，在执行java的命令中使用-Xbootclasspath选项指定附加的类。这个加载器的是非常特殊的，它实际上不是 java.lang.ClassLoader的子类，而是由JVM自身实现的。大家可以通过执行以下代码来获得bootstrap classloader加载了那些核心类库：

   URL[] urls=sun.misc.Launcher.getBootstrapClassPath().getURLs();
   for (int i = 0; i < urls.length; i++) {
     System.out.println(urls.toExternalform());
   }

在我的系统下执行为:

file:/usr/lib/locale/jdk/jre/lib/resources.jar
file:/usr/lib/locale/jdk/jre/lib/rt.jar
file:/usr/lib/locale/jdk/jre/lib/sunrsasign.jar
file:/usr/lib/locale/jdk/jre/lib/jsse.jar
file:/usr/lib/locale/jdk/jre/lib/jce.jar
file:/usr/lib/locale/jdk/jre/lib/charsets.jar
file:/usr/lib/locale/jdk/jre/lib/jfr.jar
file:/usr/lib/locale/jdk/jre/classes

这时大家知道了为什么我们不需要在系统属性CLASSPATH中指定这些类库了吧，因为JVM在启动的时候就自动加载它们了。

extension classloader －扩展类加载器，它负责加载JRE的扩展目录（JAVA_HOME/jre/lib/ext或者由java.ext.dirs系统属性指定的）中JAR的类包。这为引入除Java核心类以外的新功能提供了一个标准机制。因为默认的扩展目录对所有从同一个JRE中启动的JVM都是通用的，所以放入这个目录的 JAR类包对所有的JVM和system classloader都是可见的。在这个实例上调用方法getParent()总是返回空值null，因为引导加载器bootstrap classloader不是一个真正的ClassLoader实例。所以当大家执行以下代码时：

  System.out.println(System.getProperty("java.ext.dirs"));
   ClassLoader extensionClassloader=ClassLoader.getSystemClassLoader().getParent();
   System.out.println("the parent of extension classloader : "+extensionClassloader.getParent());

结果为：

/usr/lib/locale/jdk/jre/lib/ext:/usr/java/packages/lib/ext
the parent of extension classloader : null

extension classloader是system classloader的parent，而bootstrap classloader是extension classloader的parent，但它不是一个实际的classloader，所以为null。

system classloader －系统（也称为应用）类加载器，它负责在JVM被启动时，加载来自在命令java中的-classpath或者java.class.path系统属性或者 CLASSPATH*作系统属性所指定的JAR类包和类路径。总能通过静态方法ClassLoader.getSystemClassLoader()找到该类加载器。如果没有特别指定，则用户自定义的任何类加载器都将该类加载器作为它的父加载器。执行以下代码即可获得：
System.out.println(System.getProperty(“java.class.path”));
输出结果则为用户在系统属性里面设置的CLASSPATH。

3.类的加载流程

当运行一个程序的时候，JVM启动，运行bootstrapclassloader，该ClassLoader加载java核心API（ExtClassLoader和AppClassLoader也在此时被加载），然后调用ExtClassLoader加载扩展API，最后AppClassLoader加载CLASSPATH目录下定义的Class，这就是一个程序最基本的加载流程。

每个ClassLoader加载Class的过程是：

1.检测此Class是否载入过（即在cache中是否有此Class），如果有到8,如果没有到2
2.如果parent classloader不存在（没有parent，那parent一定是bootstrap classloader了），到4
3.请求parent classloader载入，如果成功到8，不成功到5
4.请求jvm从bootstrap classloader中载入，如果成功到8
5.寻找Class文件（从与此classloader相关的类路径中寻找）。如果找不到则到7.
6.从文件中载入Class，到8.
7.抛出ClassNotFoundException.
8.返回Class.

其中5.6步我们可以通过覆盖ClassLoader的findClass方法来实现自己的载入策略。甚至覆盖loadClass方法来实现自己的载入过程。

4.类加载器的顺序是：

先是bootstrap classloader，然后是extension classloader，最后才是system classloader。大家会发现加载的Class越是重要的越在靠前面。这样做的原因是出于安全性的考虑，试想如果system classloader“亲自”加载了一个具有破坏性的“java.lang.System”类的后果吧。这种委托机制保证了用户即使具有一个这样的类，也把它加入到了类路径中，但是它永远不会被载入，因为这个类总是由bootstrap classloader来加载的。大家可以执行一下以下的代码：

   System.out.println(System.class.getClassLoader());

将会看到结果是null，这就表明java.lang.System是由bootstrap classloader加载的，因为bootstrap classloader不是一个真正的ClassLoader实例，而是由JVM实现的，正如前面已经说过的。

5.类加载器的原理：

ClassLoader使用的是双亲委托模型来搜索类的，每个ClassLoader实例都有一个父类加载器的引用（不是继承的关系，是一个包含的关系），虚拟机内置的类加载器（Bootstrap ClassLoader）本身没有父类加载器，但可以用作其它ClassLoader实例的的父类加载器。当一个ClassLoader实例需要加载某个类时，它会试图亲自搜索某个类之前，先把这个任务委托给它的父类加载器，这个过程是由上至下依次检查的，首先由最顶层的类加载器Bootstrap ClassLoader试图加载，如果没加载到，则把任务转交给Extension ClassLoader试图加载，如果也没加载到，则转交给App ClassLoader 进行加载，如果它也没有加载得到的话，则返回给委托的发起者，由它到指定的文件系统或网络等URL中加载该类。如果它们都没有加载到这个类时，则抛出ClassNotFoundException异常。否则将这个找到的类生成一个类的定义，并将它加载到内存当中，最后返回这个类在内存中的Class实例对象。

为什么要使用双亲委托这种模型呢？

   因为这样可以避免重复加载，当父亲已经加载了该类的时候，就没有必要子ClassLoader再加载一次。考虑到安全因素，我们试想一下，如果不使用这种委托模式，那我们就可以随时使用自定义的String来动态替代java核心api中定义的类型，这样会存在非常大的安全隐患，而双亲委托的方式，就可以避免这种情况，因为String已经在启动时就被引导类加载器（Bootstrcp ClassLoader）加载，所以用户自定义的ClassLoader永远也无法加载一个自己写的String，除非你改变JDK中ClassLoader搜索类的默认算法。

JVM在搜索类的时候，又是如何判定两个class是相同的呢？

 JVM在判定两个class是否相同时，不仅要判断两个类名是否相同，而且要判断是否由同一个类加载器实例加载的。只有两者同时满足的情况下，JVM才认为这两个class是相同的。就算两个class是同一份class字节码，如果被两个不同的ClassLoader实例所加载，JVM也会认为它们是两个不同class。比如网络上的一个Java类org.classloader.simple.NetClassLoaderSimple，javac编译之后生成字节码文件NetClassLoaderSimple.class，ClassLoaderA和ClassLoaderB这两个类加载器并读取了NetClassLoaderSimple.class文件，并分别定义出了java.lang.Class实例来表示这个类，对于JVM来说，它们是两个不同的实例对象，但它们确实是同一份字节码文件，如果试图将这个Class实例生成具体的对象进行转换时，就会抛运行时异常java.lang.ClassCaseException，提示这是两个不同的类型。

这里写图片描述

6.改变类在JVM中被加载器加载的策略

我们知道自己定义的类是被App ClassLoader所加载的，如果想让Custom Class类被BootStrap ClassLoader加载有如下两部分操作(首先将其压缩成jar，例如Custom.jar)：

1、在jvm中添加-Xbootclasspath参数，指定Bootstrcp ClassLoader加载类的路径，并追加我们自已的jar (Custom.jar)
2、将class文件放到JAVA_HOME/jre/classes/目录下

7.定义自已的ClassLoader

Java中提供的默认ClassLoader，只加载指定目录下的jar和class，如果我们想加载其它位置的类或jar时，比如：我要加载网络上的一个class文件，通过动态加载到内存之后，要调用这个类中的方法实现我的业务逻辑。在这样的情况下，默认的ClassLoader就不能满足我们的需求了，所以需要定义自己的ClassLoader。

定义自已的类加载器分为两步：

1、继承java.lang.ClassLoader
2、重写父类的findClass方法

上述提到过ClassLoader一共有6个方法，但只需重写findClass即可。因为JDK已经在loadClass方法中帮我们实现了ClassLoader搜索类的算法，当在loadClass方法中搜索不到类时，loadClass方法就会调用findClass方法来搜索类，所以我们只需重写该方法即可。如没有特殊的要求，一般不建议重写loadClass搜索类的算法。

对于如下一个类：

package main;

public class SayHello {
   public void say() {
       System.out.println("hello world");
   }
}

将其编译为class文件后，至于远程服务器，并保证http协议能够访问。
编写类加载器(继承ClassLoader)

public class NetworkClassLoader extends ClassLoader{
    private String ROOTURL = "http://localhost:8080/";
    private String PACKAGE = "main.";

    @Override  
    protected Class<?> findClass(String name)  throws ClassNotFoundException{

        Class<?> clazz = this.findLoadedClass(name);//找名称为 name 的已经被加载过的类，返回的结果是 java.lang.Class 类的实例
        if(clazz == null) {
          byte[] classData = getClassData(name);  //根据类的二进制名称,获得该class文件的字节码数组  
          if (classData == null) {  
              throw new ClassNotFoundException();  
          }
          clazz = defineClass(PACKAGE+name, classData, 0, classData.length);  //将class的字节码数组转换成Class类的实例  
        }
        return clazz; 
    }

    private byte[] getClassData(String name) {
        String path = ROOTURL+name+".class";
        URL url;
        InputStream is = null;
        try {
            url = new URL(path);
            byte[] buff = new byte[1024*4];
            is = url.openStream();
            int len = 1;
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            while((len = is.read(buff)) != -1) {
                os.write(buff, 0, len);
            }
            return os.toByteArray();  
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(is!=null) {
                try {
                  is.close();
                }catch(IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;

    }
}

Main.java

public class Main {

  public static void main(String[] args) {

      NetworkClassLoader ncl = new NetworkClassLoader();
      try {
        Class<?> clazz = ncl.findClass("SayHello");

        //通过反射执行被加载的方法
        clazz.getMethod("say").invoke(clazz.newInstance());  
      } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
        e.printStackTrace();
      }
  }

}