coding……
但行好事 莫问前程
当前位置：Zhuoli's Blog > Java > 正文

Java编程拾遗『Java ClassLoader工作机制』

2019-10-23 分类：Java / Java编程拾遗 阅读(1942) 评论(0)

ClassLoader顾名思义就是类加载器，负责将类的.class文件中的二进制数据加载到JVM中，然后在堆区创建一个java.lang.Class对象，用来封装类在方法区内的数据结构（类的方法代码，变量名，方法名，访问权限，返回值等）。类的加载的最终产品是位于堆区中的Class对象， Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口。

类加载器通常可以通过如下方式加载.class：

  • 从本地系统中直接加载
  • 将Java源文件动态编译为.class文件
  • 通过网络下载.class文件
  • 从zip，jar等归档文件中加载.class文件
  • 从专有数据库中提取.class文件

本文会着重介绍ClassLoader的类加载机制及加载过程，最后通过实现自定义类加载器的方式来回顾上面的理论性知识。

1. ClassLoaser类结构分析

在使用类加载器时，我们通常会使用或扩展ClassLoader，这里我们首先来介绍一下抽象类ClassLoader，如下：

当我们使用ClassLoader时，主要会用到如上红框圈出的方法，这里分别介绍一下。

loadClass：loadClass负责将.class的二进制数据加载到JVM，并生成类加载的最终产品——类的Class对象。其中loadClass方法的参数name是类的名称，这里需要注意的是，name必须上送类的全名（如com.zhuoli.service.custome.Cat），否则会报NoClassDefFoundError，这一点会在后面自定义实现类加载器中介绍。

defineClass：defineClass方法用来将byte字节流解析成JVM能够识别的Class对象，有了这个方法意味着我们不仅可以通过class文件实例化对象，还可以通过其它方式实例化对象，比如通过网络接受一个类的字节码，然后那这个字节码二进制流直接创建类的Class对象。不过需要注意的是，调用defineClass方法只是生成类的Class对象，这个类的Class对象还没有resolve，resolve操作将会在通过Class对象生成实例对象时（比如调用Class对象的newInstance方法）进行。

findClass：defineClass方法通常是和findClass方法一起使用的，我们一般通过覆盖抽象类ClassLoader的findClass方法，来实现自定义类的加载规则（比如字节码解密），从而得到待加载类的字节码二进制流。然后调用defineClass方法生成类的Class对象。

resolveClass：类的加载分为两个阶段，加载和链接（链接又可以细分为：验证、准备、解析、初始化，下面在讲类加载过程时会介绍）。在调用defineClass将类加载到JVM，并生成Class对象后，只是实现了加载，并没有被链接。通过调用resolveClass方法，就可以实现类在被加载到JVM中时就被链接。当然，我们也可以选择让JVM来解决什么时候链接这个类。

如果我们不想重新定义加载类的规则，也没有复杂的处理逻辑，只想在运行时能够加载自己指定的一个类。那么可以用this.getClass().getClassLoader().loadClass(className)调用ClassLoader的loadClass方法以获取指定类的Class对象。

2. ClassLoaser类加载机制

比如我们自定义一个类Cat，并通过打包工具同时将Cat类输出到jre/lib/ext包下和classPath下，这时候ext目录及classPath目录下同时存在Cat.class，那么当我们要使用Cat类时，到底使用的是ext目录下的Cat类还是classPath目录下的Cat类，这就涉及到Java类的加载机制。

2.1 类加载器

在了解类的加载机制之前，我们需要先了解一下类加载器，在Java中大致存在一下三种类加载器：

  • 启动类加载器：BootstrapClassLoader，负责加载存放在 JDK\jre\lib(JDK代表JDK的安装目录，下同)下，或被 -Xbootclasspath参数指定的路径中的，并且能被虚拟机识别的类库（如rt.jar，所有的java.开头的类均被 BootstrapClassLoader加载）。启动类加载器是无法被Java程序直接引用的。
  • 扩展类加载器：ExtensionClassLoader，该加载器由 sun.misc.Launcher$ExtClassLoader实现，它负责加载 JDK\jre\lib\ext目录中，或者由java.ext.dirs系统变量指定的路径中的所有类库（如javax.开头的类），开发者可以直接使用扩展类加载器。
  • 应用程序类加载器：ApplicationClassLoader，该类加载器由 sun.misc.Launcher$AppClassLoader来实现，它负责加载用户类路径（ClassPath）所指定的类，开发者可以直接使用该类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。

应用程序都是由这三种类加载器互相配合进行加载的，如果有必要，我们还可以加入自定义的类加载器。因为JVM自带的ClassLoader只能从本地文件系统加载标准的java class文件，因此如果编写了自己的ClassLoader，便可以做到如下几点：

  • 在执行非置信代码之前，自动验证数字签名
  • 从特定的场所取得java class，例如数据库中和网络中
  • 动态地创建符合用户特定需要的定制化构建类

2.2 Java ClassLoader类加载机制

说到Java类的加载机制，一般都会给出如下标准答案：

  • 全盘负责，当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入
  • 双亲委托，先让父类加载器试图加载该类，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类
  • 缓存机制，缓存机制将会保证所有加载过的Class都会被缓存，当程序中需要使用某个Class时，类加载器先从缓存区寻找该Class，只有缓存区不存在，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存入缓存区。这就是为什么修改了Class后，必须重启JVM，程序的修改才会生效

答案肯定是正确的，关键在于理解上。我记得我最开始接触类加载器，读到这段话时，我的理解是上述三种机制是ClassLoader可选的加载机制，不同的ClassLoader可以选择不同的加载机制，而双亲委托是一种比较“先进”的加载方式，就像垃圾回收器中的CMS、G1一样，当然这样理解肯定是错误的。

上述罗列的三点合在一起，才是Java ClassLoader的类加载机制，换句话讲，每一个ClassLoader都遵循了上述这三点机制。可以讲Java ClassLoader的类加载机制是“使用缓存的全盘负责委托机制”。缓存这点很好理解，我们着重来看一下全盘负责和父类委托这两个特性。

应用程序类加载器AppClassLoader加载入口类（含有main方法的类）时，会把main方法所依赖的类及引用的类也载入，依此类推。“全盘负责”机制也可称为当前类加载器负责机制。显然，入口类所依赖的类及引用的类使用的类加载器也是入口类的类加载器。

但是需要注意的是，全盘负责只是确定了类使用的类加载器，即只是确定了调用classLoader.loadClass(name)方法的classLoader，并没有真正定义类。真正加载class字节码文件生成Class对象由“双亲委托”机制完成。

“双亲委托”加载Class的具体过程如下：

  • 源ClassLoader先判断该Class是否已加载，如果已加载，则返回Class对象；如果没有则委托给父类加载器
  • 父类加载器判断是否加载过该Class，如果已加载，则返回Class对象；如果没有则委托给祖父类加载器
  • 依此类推，直到始启动类加载器
  • 启动类加载器判断是否加载过该Class，如果已加载，则返回Class对象；如果没有则尝试从其对应的类路径下寻找class字节码文件并载入。如果载入成功，则返回Class对象；如果载入失败，则委托给启动类加载器的子类加载器
  • 启动类加载器子类加载器尝试从其对应的类路径下寻找class字节码文件并载入。如果载入成功，则返回Class对象；如果载入失败，则委托给启动类加载器的孙类加载器
  • 依此类推，直到源ClassLoader
  • 源ClassLoader尝试从其对应的类路径下寻找class字节码文件并载入。如果载入成功，则返回Class对象；如果载入失败，源ClassLoader不会再委托其子类加载器，而是抛出异常

这里就体现了缓存机制和双亲委托机制，我们可以很明确得到结论：双亲委托机制可以保证字节码只被加载一次。另外，双亲委托机制只是Java推荐的机制，并不是强制的机制。我们可以继承java.lang.ClassLoader类，实现自己的类加载器。如果想保持双亲委派模型，就应该重写findClass(name)方法。如果想破坏双亲委派模型，可以重写loadClass(name)方法。

3. 类加载过程

类的加载过程包括加载、验证、准备、解析、初始化五个阶段（也可以分为加载、链接和初始化三个阶段），这五个阶段中，加载、验证、准备和初始化这四个阶段发生的顺序是确定的，而解析阶段则不一定，它在某些情况下可以在初始化阶段之后开始，这是为了支持Java语言的运行时绑定。另外注意这里的几个阶段是按顺序开始，而不是按顺序进行或完成，因为这些阶段通常都是互相交叉地混合进行的，通常在一个阶段执行的过程中调用或激活另一个阶段。

3.1 加载

在加载阶段，虚拟机完成以下三件事情：

  • 通过一个类的全限定名来获取其定义的二进制字节流
  • 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
  • 在Java堆中生成一个代表这个类的java.lang.Class对象，作为对方法区中这些数据的访问入口

不难发现，加载阶段也就是ClassLoader类中findClass方法完成的工作一致。相对于类加载的其他阶段而言，加载阶段是可控性最强的阶段，因为开发人员既可以使用系统提供的类加载器来完成加载，也可以自定义自己的类加载器来完成加载。

加载阶段完成后，虚拟机外部的二进制字节流就按照虚拟机所需的格式存储在方法区之中，而且在Java堆中也创建一个 java.lang.Class类的对象，这样便可以通过该对象访问方法区中的这些数据。

3.2 链接

链接阶段又可以细分为准备、解析和初始化三个子阶段。

3.2.1 验证

验证是链接阶段的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，不会危害虚拟机自身的安全。验证阶段大致会完成4个阶段的检验动作：

  • 文件格式验证：验证字节流是否符合Class文件格式的规范；例如：是否以 0xCAFEBABE开头、主次版本号是否在当前虚拟机的处理范围之内、常量池中的常量是否有不被支持的类型
  • 元数据验证：对字节码描述的信息进行语义分析（注意：对比javac编译阶段的语义分析），以保证其描述的信息符合Java语言规范的要求；例如：这个类是否有父类，除了 java.lang.Object之外
  • 字节码验证：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的
  • 符号引用验证：确保解析动作能正确执行

验证阶段是非常重要的，但不是必须的，它对程序运行期没有影响，如果所引用的类经过反复验证，那么可以考虑采用 -Xverifynone参数来关闭大部分的类验证措施，以缩短虚拟机类加载的时间。

3.2.2 准备

准备阶段目的是为类变量分配内存并设置类变量初始值，这些内存都将在方法区中分配。对于该阶段有以下几点需要注意：

  • 这时候进行内存分配的仅包括类变量（static），而不包括实例变量，实例变量会在对象实例化时随着对象一块分配在Java堆中
  • 这里所设置的初始值通常情况下是数据类型默认的零值（如0、0L、null、false等），而不是被在Java代码中被显式地赋予的值

假设一个类变量的定义为：

public static int value = 3;
  • 如果类字段的字段属性表中存在 ConstantValue属性，即同时被final和static修饰，那么在准备阶段变量value就会被初始化为ConstValue属性所指定的值

假设上面的类变量value被定义为：

public static final int value = 3;

编译时Javac将会为value生成ConstantValue属性，在准备阶段虚拟机就会根据 ConstantValue的设置将value赋值为3。我们可以理解为static final常量在编译期就将其结果放入了调用它的类的常量池中。

最后，我们来总结一下各种属性修饰变量的使用规则：

  • 对基本数据类型来说，对于类变量（static）和全局变量，如果不显式地对其赋值而直接使用，则系统会为其赋予默认的零值，而对于局部变量来说，在使用前必须显式地为其赋值，否则编译时不通过
  • 对于同时被static和final修饰的常量，必须在声明的时候就为其显式地赋值，否则编译时不通过；而只被final修饰的常量则既可以在声明时显式地为其赋值，也可以在类初始化时显式地为其赋值，总之，在使用前必须为其显式地赋值，系统不会为其赋予默认零值
  • 对于引用数据类型reference来说，如数组引用、对象引用等，如果没有对其进行显式地赋值而直接使用，系统都会为其赋予默认的零值，即null
  • 如果在数组初始化时没有对数组中的各元素赋值，那么其中的元素将根据对应的数据类型而被赋予默认的零值

3.2.3 解析

解析阶段的目的是虚拟机将常量池内的符号引用替换为直接引用，解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行。符号引用就是一组符号来描述目标，可以是任何字面量。

直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。

3.3 初始化

初始化阶段，主要是为类的静态变量赋予正确的初始值。JVM负责对类进行初始化，主要对类变量进行初始化。在Java中对类变量进行初始值设定有两种方式：

  • 声明类变量是指定初始值
  • 使用静态代码块为类变量指定初始值

JVM初始化步骤：

  1. 假如这个类还没有被加载和连接，则程序先加载并连接该类
  2. 假如该类的直接父类还没有被初始化，则先初始化其直接父类
  3. 假如类中有初始化语句，则系统依次执行这些初始化语句

只有当对类的主动使用的时候才会导致类的初始化，类的主动使用包括以下六种：

  • 创建类的实例，也就是new的方式
  • 访问某个类或接口的静态变量，或者对该静态变量赋值
  • 调用类的静态方法
  • 反射
  • 初始化某个类的子类，则其父类也会被初始化
  • Java虚拟机启动时被标明为启动类的类（ JavaTest），直接使用 java.exe命令来运行某个主类

4. 自定义类加载器

通常情况下，我们直接直接使用系统类加载器就可以满足我们的需求。但是，有的时候，比如应用是通过网络来传输 Java类的字节码，为保证安全性，这些字节码经过了加密处理，这时系统类加载器就无法对其进行加载，这样则需要自定义类加载器来实现。自定义类加载器一般都是继承自 ClassLoader类，并重写 findClass 方法即可。下面我们通过一个示例来演示通过网络传输加密后的字节码，并通过自定义类加载器家在的流程。

首先自定义一个待传输的类Cat：

package com.zhuoli.service.spring.explore.trans;

/**
 * @author zhuoli
 * @ClassName Cat.java
 * @Description
 * @createTime 2019/11/07 20:35:00
 */
public class Cat {
    public void say() {
        System.out.println("I am a cat");
    }
}

class文件加密方法：

package com.zhuoli.service.spring.explore.utils;

import java.io.*;

/**
 * @author zhuoli
 * @ClassName EncryptUtil.java
 * @Description
 * @createTime 2019/11/07 20:54:00
 */
public class EncryptUtil {
    public static byte[] encrypt(InputStream inputStream) throws IOException {

        byte[] bytes;
        try (ByteArrayOutputStream output = new ByteArrayOutputStream()) {
            byte[] buf = new byte[1024];
            int bytesRead;
            while ((bytesRead = inputStream.read(buf)) != -1) {
                output.write(buf, 0, bytesRead);
            }
            bytes = output.toByteArray();
        }
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = (byte) (bytes[i] ^ 0xff); //加密，0变成1，1变成0
        }
        return bytes;
    }
}

原理比较简单，其实就是将二进制数组的每个元素跟0xff异或，这样就能将0 变成1，1变成0。在接收端，拿到二进制数组，在跟0xff异或一次，就能将二进制数组还原了。这里只是做个简单的示例，实际使用中可以有很多种加密方法选择。

最后在应用中，通过暴露http接口的方式，提供远端下载class文件的途径：

@RestController
@RequestMapping(value = "/clazz")
public class HelloWorldController {

    @RequestMapping(value = "download", method = RequestMethod.GET)
    public ResponseEntity<byte[]> download() throws IOException {
        HttpHeaders headers = new HttpHeaders();
        //设置文件名
        headers.setContentDispositionFormData("attachment", "Cat.class");

        //读取class文件
        File byteFile = ResourceUtils.getFile(ResourceUtils.CLASSPATH_URL_PREFIX + "com/zhuoli/service/spring/explore/trans/Cat.class");

        //class文件加密
        try (FileInputStream inputStream = new FileInputStream(byteFile)) {
            byte[] bytes = EncryptUtil.encrypt(inputStream);
            return new ResponseEntity<>(bytes, headers, HttpStatus.OK);
        }
    }
}

我们再起一个应用，自定义类加载器，实现对网络字节码的加载：

public class CustomClassLoader extends ClassLoader {

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] data = new byte[0];
        try {
            data = this.loadClassData();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return this.defineClass(name, data, 0, data.length);
    }

    /**
     * 加载二进制文件
     *
     * @return
     */
    private byte[] loadClassData() throws IOException {

        HttpClient client = new DefaultHttpClient();
        HttpGet request = new HttpGet("http://127.0.0.1:8080/clazz/download");

        //添加请求头
        request.addHeader("User-Agent", USER_AGENT);

        HttpResponse response = client.execute(request);

        try (InputStream inputStream = response.getEntity().getContent();
             ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
            int ch;
            byte[] data;
            while (-1 != (ch = inputStream.read())) {
                ch = ch ^ 0xff; //解密
                outputStream.write(ch);
            }
            data = outputStream.toByteArray();
            return data;
        }
    }
}

通过HttpClient，下载远端的字节码数组，并解密。然后调用父类ClassLoader的defineClass方法，创建Class对象。下面来看一下自定义类加载器的使用：

public class ClassLoaderTest {
    public static void main(String[] args) throws Exception {
        CustomClassLoader loader = new CustomClassLoader();
        Class<?> clazz = loader.loadClass("com.zhuoli.service.spring.explore.trans.Cat"); //远端下载class byte[]，并使用自定义类加载器加载
        Object object = clazz.newInstance();
        Method method = clazz.getMethod("say");
        method.invoke(object);
    }
}

运行结果：

I am a cat

说明我们自定义的类加载器正确实现了对网络字节码的加载。这里有一点要说明的是，loadClass方法参数必须传待加载类的全限定名，否则会报NoClassDefError，最终报错的地方是再一个native方法中抛出的，具体细节没有再去验证。之前看了很多博客，都讲loadClass方法的参数可以不用传类的全限定名，我这里表示非常疑惑，如果有大佬非常清除这一块的内容，希望可以给解释一下。

关于自定义类加载器，需要注意的是：

  • loadClass方法的参数，必须传待加载类的全限定名，如”com.zhuoli.service.spring.explore.trans.Cat”
  • 如果想保持双亲委派模型，就应该重写findClass(name)方法。如果想破坏双亲委派模型，可以重写loadClass(name)方法
  • 如果是加载本地class文件，class文件不要放在classPath下，否则由于双亲委托机制，待加载的类会被AppClassLoader加载，而不会被自定义类加载器加载

5. 类的加载方式

Java中类主要通过如下几种方式加载：

  • 命令行启动应用时候由JVM初始化加载
  • 通过Class.forName()方法动态加载
  • 通过ClassLoader.loadClass()方法动态加载

这里再特别讲一下，Class.forName()和ClassLoader.loadClass()的区别：

  • Class.forName()：把类的.class文件加载到JVM中，对类进行解释的同时执行类中的static静态代码块
  • ClassLoader.loadClass()：只是把.class文件加载到JVM中，不会执行static代码块中的内容，只有在newInstance才会去执行

参考链接：

1. 《深入了解java虚拟机》

2. jvm系列(一):java类的加载机制

3. Hotpot Java虚拟机Class对象是在方法区还是堆中

4. JVM系列(五) – JVM类加载机制详解

赞(0) 打赏
Zhuoli's Blog » Java编程拾遗『Java ClassLoader工作机制』
分享到： 更多 (0)
标签：

相关推荐

评论 抢沙发

取消

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

热门标签

java (63)Java编程拾遗 (55)Spring Boot (22)源码分析 (16)Spring (16)java基础 (15)mybatis (13)mysql (11)java8 (10)Guava (10)Spring MVC (6)tomcat (5)list (3)redis (3)事务 (3)dubbo (3)IOC容器 (3)DateTime (2)日志 (2)Map (2)服务器 (2)Nginx (2)限流 (2)JVM (2)jackson (1)json (1)序列化 (1)lambda (1)Git (1)Lombok (1)

置顶推荐