00-JAVA基础-JVM类加载机制及自定义类加载器

丨Anna丨2024-04-09 15:41

JVM 类加载机制

JVM类加载机制是Java运行时环境的核心部分，它负责将类的.class文件加载到JVM中，并将其转换为可以被JVM执行的数据结构。

类加载的整体流程

类加载的整体流程可以分为五个阶段：加载（Loading）、链接（Linking）、初始化（Initialization）、使用和卸载（Unloading）。其中，链接阶段又可以细分为验证（Verification）、准备（Preparation）和解析（Resolution）三个阶段。

加载阶段

  • 系统提供的类加载器或自定义类加载器：首先，通过类加载器（可以是系统提供的，也可以是用户自定义的）根据类的全名（包括包名）找到对应的.class文件。
  • 读取.class文件：类加载器从文件系统或网络等位置读取.class文件的二进制数据。
  • 创建Class对象：将读取到的二进制数据转换为方法区的运行时数据结构，并在堆区创建一个java.lang.Class对象，这个Class对象作为该类在JVM中的元数据表示。

链接阶段

  • 验证阶段：
    • 文件格式验证：验证.class文件是否符合JVM规范，是否是一个有效的字节码文件。
    • 元数据验证：验证字节码中的元数据是否符合Java语言规范。
    • 字节码验证：验证字节码的执行是否符合Java虚拟机规范。
    • 符号引用验证：验证类中的符号引用是否有效，能否被正确解析。
    • 准备阶段：为类的静态变量分配内存空间，并设置初始值（注意，这里的初始值不是代码中显式赋予的值，而是根据变量的数据类型赋予的默认值，如int为0，引用类型为null）。
    • 解析阶段：将常量池中的符号引用转换为直接引用。符号引用是一个抽象的概念，如字段名、方法名等，而直接引用则是指向内存中的具体地址。

初始化阶段

  • 初始化阶段是执行类构造器()方法的过程。类构造器()方法是由编译器自动收集类中的所有变量的赋值动作和静态代码块（static代码块）中的语句合并产生的。
  • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先初始初始化其父类。
  • JVM会保证一个类的()方法在多线程环境中被正确的加锁和同步。因此JVM中一个类的class是线程安全的。
  • 只有当类或接口的静态变量被首次主动使用时，JVM才会初始化这个类或接口。
类的主动引用（一定会发生类的初始化）
  • new一个类的对象
  • 调用类的静态成员（除了final常量）和静态方法
  • 使用java.lang.reflect包的方法对类进行反射调用
  • 当JVM启动，java Hello,则一定会初始化Hello类（即先启动main方法说在的类）
  • 当初始化一个类，如果其父类没有被初始化，则会先初始化它的父类

注意：

一个类被初始化后，不会重复进行被初始化

类的被动引用（不会发生类的初始化）
  • 当访问一个静态属性是，只有真正声明这个域的类才会被初始化
    • 通过子类引用父类的静态变量，不会导致子类初始化
  • 通过数组定义引用，不会触发此类的初始化
  • 引用常量不会触发此类的初始化（因为常量在编译节点就存入调用类的常量池中了）

使用和卸载阶段

  • 类被初始化后，就可以被JVM使用，创建实例对象、调用方法等。
  • 当类不再被使用时，JVM会将其从内存中卸载，释放其占用的资源。

测试类的加载机制

创建一个A对象和一个B对象，使B对象继承A，测试时初始化A，查看JVM类的加载过程

A.java

java 复制代码 
package demo;

public class A {

    /** 定义一个静态属性 */
    public static String NAME = "A";

    /** 定义一个final 静态常量 */
    public static final int AGE = 20;

    static {
        System.out.println("A static 代码块被调用了");
        NAME = "static 修改了 NAME";
    }

    public A(){
        System.out.println("A 默认构造方法被调用了");
    }

}

B.java

java 复制代码 
package demo;

public class B extends A {

    /** 定义一个静态属性 */
    private static String TYPE = "A";

    /** 定义一个final 静态常量 */
    private static final int WIDTH = 20;

    static {
        System.out.println("B static 代码块被调用了");
        TYPE = "static 修改了 TYPE";
    }

    public B(){
        System.out.println("B 默认构造方法被调用了");
    }

}

ClassLoadDemo.java

java 复制代码 
package demo;

/**
 * 测试JVM类的加载机制
 *
 * @author Anna.
 * @date 2024/4/5 14:14
 */
public class ClassLoadDemo {

  static {
    System.out.println("mian方法所在类的 static 代码块被调用了");
  }

  public static void main(String[] args) {
    new B();

    System.out.println("初始化完成后-第二次调用不会重复进行初始化");
    new B();
  }
}

执行结果：

结论：

一个类初始化时，如果其父类没有被初始化，则先初始化其父类。

一个类被初始化后，再次被引用时，则不会重复初始化。

new 对象会默认调用类的无参构造方法

测试类的主动引用,一定会发生类的初始化

类定义使用上述A.java及B.java

  • 通过new一个对象
java 复制代码 
public class ClassLoadDemo1 {

  public static void main(String[] args) {
    System.out.println("========1 通过new========");
    new A();
  }
}

执行结果：

  • 调用类的静态成员（除了final常量）和静态方法
java 复制代码 
package demo;

public class ClassLoadDemo1 {

  public static void main(String[] args) {
    System.out.println("========2 调用类的静态成员（除了final常量）和静态方法========");
    System.out.println("调用final常量：");
    System.out.println("A.AGE:" + A.AGE);
    System.out.println("调用非final静态成员常量：");
    System.out.println("A.NAME:" + A.NAME);
  }
}

执行结果：

  • 使用java.lang.reflect包的方法对类进行反射调用
java 复制代码 
package demo;
public class ClassLoadDemo1 {

    public static void main(String[] args) throws Exception {
        System.out.println("========3 反射调用========");
        Class.forName("demo.A");
    }
}

执行结果：

类的被动引用,不会发生类的初始化

  • 通过子类引用父类的静态变量，不会导致子类初始化
java 复制代码 
package demo;
public class ClassLoadDemo2 {

    public static void main(String[] args) {
        System.out.println("========通过子类引用父类的静态变量，不会导致子类初始化========");
        System.out.println("========子类引用父类final常量，既不初始化父类，也不初始化子类========");
        System.out.println("B.AGE" + B.AGE);
        System.out.println("========子类引用父类非final常量，初始化父类，但不初始化子类========");
        System.out.println("B.NAME" + B.NAME);
    }
}

执行结果：

  • 通过数组定义引用，不会触发此类的初始化
java 复制代码 
package demo;
public class ClassLoadDemo2 {

    public static void main(String[] args) {
        System.out.println("========2 通过数组定义引用，不会触发此类的初始化========");
        A[] arr = new A[10];

    }
}

执行结果：

类加载器

  • Java类加载器（Java Classloader）是Java运行时环境（Java Runtime Environment）的重要组成部分，负责动态加载Java类到Java虚拟机的内存空间中。
  • 类加载器在Java程序中扮演着至关重要的角色，它确保了类的正确加载、链接和初始化，为程序的执行提供了基础。

类加载器的层次结构

Java类加载器的层次结构是一个有序的组织形式，它定义了类加载器之间的父子关系和加载范围，确保了Java程序的正确运行。

Java类加载器的层次结构通常包括四种主要类型的类加载器：启动类加载器（Bootstrap ClassLoader）、扩展类加载器（Extension ClassLoader）、应用程序类加载器（Application ClassLoader）和自定义类加载器。这些类加载器按照父子关系组织，形成了一个有序的加载链。

  • 启动类加载器（Bootstrap ClassLoader）：
    • 是Java虚拟机的一部分，通常由本地代码实现（C语言），负责加载Java核心类库，如java.lang包中的类。
    • 由于是由本地代码实现的，因此并不基础自java.lang.classLoader。在Java代码中无法直接获取其引用。
    • 负责加载JVM运行时环境所需的基础类库，是所有类加载器的根加载器。
  • 扩展类加载器（Extension ClassLoader）：
    • 是由Java语言实现的，用于加载Java扩展类库，如javax包中的类。
    • 它的父加载器是启动类加载器（但无法通过java获取其父类）。
    • 可以通过系统属性"java.ext.dirs"来指定扩展类库的路径。
  • 应用程序类加载器（Application ClassLoader）：
    • 也称为系统类加载器，是默认的类加载器，负责加载应用程序的类路径（classpath,java.lang.path）下的类文件。
    • 它的父加载器是扩展类加载器。
    • 可以通过ClassLoader类的getSystemClassLoader()方法获取到它的引用。
    • 有sum.misc.Launcher$AppClassLoader实现
  • 自定义类加载器
    • 开发者可以通过基础java.lang.ClassLoader类的方式实现自己的类加载器，以满足一些特殊需求。

层次结构的优势

  • 安全性：通过双亲委派机制，确保了Java核心类库的安全性，防止了恶意代码通过自定义类加载器来篡改或替换核心类库。
  • 有序性：层次结构确保了类的加载是有序的，避免了类的重复加载。
  • 灵活性：通过自定义类加载器，可以实现热加载、隔离加载环境、加载加密类文件等高级功能。

ClassLoader介绍

作用
  • java.lang.ClassLoader类的基本职责就是根据一个指定的类的名称，找到或者生成其对于的字节代码，然后从这些字节代码中定义出第一个Java类，即java.lang.Class类的一个实例。
相关方法
方法 描述
loadClass(String name) 这是 ClassLoader 的核心方法，用于加载指定的类。当应用程序请求加载一个类时，ClassLoader 首先会检查这个类是否已经被加载过。如果已经加载过，就直接返回该类的 Class 对象。否则，会尝试加载该类。 如果 ClassLoader 自己无法找到类，它会根据双亲委派模型将请求委托给父类加载器。如果父类加载器也无法加载类，那么 ClassLoader 会尝试自己加载类。
findClass(String name) 这是一个受保护的方法，用于查找指定名称的类。当 ClassLoader 需要自己加载类时，它会调用该方法。具体的类加载逻辑通常会在该方法中实现。 在自定义 ClassLoader 时，开发人员可以重写该方法以实现自己的类加载逻辑。
findLoadedClass(String name) 该方法用于查找已经由当前 ClassLoader 加载的类。如果该类已经被加载，则返回对应的 Class 对象；否则返回 null。
findSystemClass(String name) 该方法用于查找由系统 ClassLoader（通常是 AppClassLoader）加载的类。它不会委托给父类加载器，而是直接在当前 ClassLoader 或系统 ClassLoader 中查找类。
defineClass(String name, byte[] b, int off, int len) 该方法用于将字节码数组转换为 Class 对象。它允许从字节码数组直接定义类，而不需要从文件系统或网络加载类文件。 在某些高级场景中，如动态代理或代码生成，开发人员可能会使用该方法动态地创建类。
getResource(String name) 和 getResources(String name) 这两个方法用于查找资源（如文件、图像等）。它们根据类加载器的类路径查找资源，并返回 URL 对象或 URL 对象的枚举。
getParent() 该方法返回当前 ClassLoader 的父类加载器。通过该方法，可以访问双亲委派模型中的父级加载器。

案例

java 复制代码 
package demo2;
public class ClassLoadDemo {
    public static void main(String[] args) {
        System.out.printf("获取当前应用程序类加载器：%s%n", ClassLoader.getSystemClassLoader());
        System.out.printf("获取应用程序类加载器父类加载器：%s%n", ClassLoader.getSystemClassLoader().getParent());
        System.out.printf("获取根加载器：%s%n", ClassLoader.getSystemClassLoader().getParent().getParent());

        System.out.printf("获取应用类路径：%s%n", System.getProperty("java.class.path"));
    }
}

执行结果：

类加载器的代理模式

  • 代理模式
    • 交给其他加载器来加载指定的类
  • 双亲委派机制
    • 在代理模式下，当一个类加载器收到类加载请求时，它首先会检查这个类是否已经被加载过。如果已经加载过，就直接返回这个类的Class对象。如果没有加载过，它会将这个请求委派给父类加载器去完成。这种机制称为双亲委派模型。通过逐级向上委派，最终会到达顶层的启动类加载器。如果启动类加载器无法加载该类，那么请求会逐级向下传递，直到找到能够加载该类的类加载器为止。
    • 双亲委派机制是为了保证java核心库的类型安全。这种机制保证了不会出现用户自己定义java.lang.Object类的情况
    • 类加载器除了用于加载类，也是安全的最基本的屏障
  • 双亲委派机制是代理模式的一种
    • 并不是所有的类加载器都采用双亲委派机制
    • tomcat服务器加载器也使用代理模式，所不同的是它是首先尝试去加载这个类，如果找不到在代理给父类加载器。

自定义类加载器

自定义类加载器流程：

  • 继承：java.lang.ClassLoader
  • 首先检查请求的类型是否已经被这个加载装载到了命名空间，如果已加载，则直接返回
  • 委派类加载器请求给父类加载器，如果父类加载器能够完成加载，则直接返回加载器加载的Class实例
  • 调用本类加载器的findClass()方法，试图获取对应的字节码，如果获取的到，则调用defineClass()导入类型到方法区；如果获取不到对应的字节码或者其他原因失败，返回异常给loadClass(),
  • 测试案例调用：loadClass()加载class

UserDo.java

java 复制代码 
package demo3;

/**
 * UserDo 实体
 * @author Anna.
 * @date 2024/4/5 16:31
 */
public class UserDo1 {
    private String name;
    public UserDo1(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "UserDo{" +
                "name='" + name + '\'' +
                '}';
    }
}

注意： 该类编译完成后.class文件不要放在应用目录下。JVM双亲委派机制会先使用应用类加载器进行加载，这样会导致无法测试自定义类加载器

CustomClassLoader.java

java 复制代码 
package demo3;

import java.io.*;

/**
 * 自定义类加载器
 *
 * 首先检查请求的类型是否已经被这个加载装载到了命名空间，如果已加载，则直接返回
 * + 委派类加载器请求给父类加载器，如果父类加载器能够完成加载，则直接返回加载器加载的Class实例
 * + 调用本类加载器的findClass()方法，试图获取对应的字节码，如果获取的到，则调用defineClass()导入类型到方法区；如果获取不到对应的字节码或者其他原因失败，返回异常给loadClass(),loadClass()转抛异常，终止加载过程
 * @author Anna.
 * @date 2024/4/5 16:07
 */
public class CustomClassLoader extends ClassLoader{

    /** 定义一个加载根路径 */
    private String rootDir;

    public CustomClassLoader(String rootDir){
        this.rootDir = rootDir;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 加载该类是否已经加载到命名空间
        Class<?> clazz = findLoadedClass(name);
        if (clazz != null) {
            return clazz;
        }

        // 尝试自己加载类
        byte[] classData;
        try {
            classData = getClassData(name);
        } catch (IOException e) {
            throw new ClassNotFoundException();
        }

        // 如果自己也加载不到该类，则抛出异常
        if(classData == null){
            throw new ClassNotFoundException();
        }

        // 调用defineClass()导入类型到方法区
        clazz = defineClass(name, classData, 0, classData.length);

        return clazz;
    }

    /**
     * 根据路径读取.class文件
     *
     * @param name
     * @return byte[]
     * @author Anna.
     * @date 2024/4/5 16:24
     */
    private byte[] getClassData(String name) throws IOException {
        // 将包路径转换为类路径
        String path = rootDir + File.separator + name.replace(".", File.separator) + ".class";
        // 使用字节流读取class文件
        InputStream is  = null;
        ByteArrayOutputStream baos  = null;
        try{
            is = new FileInputStream(path);
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int temp = -1;
            while ((temp = is.read(buffer)) != -1){
                baos.write(buffer,0,temp);
            }
        }
        catch (Exception e){
            throw e;
        }
        finally {
            if(is != null){
                is.close();
            }
            if(baos != null){
                baos.close();
            }
        }

        return baos.toByteArray();
    }
}

ClassLoaderDemo.java

java 复制代码 
package demo3;

/**
 * 自定义类加载器 测试
 *
 * @author Anna.
 * @date 2024/4/5 16:33
 */
public class ClassLoaderDemo {

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

        // 获取根路径
        String path = "D:";
        System.out.println(path);

        // 获取自定义类加载器
        CustomClassLoader customClassLoader = new CustomClassLoader(path);

        // 使用同一个类加载器加载UserDo
        Class<?> clazz1 = customClassLoader.loadClass("demo3.UserDo");
        Class<?> clazz2 = customClassLoader.loadClass("demo3.UserDo");
        System.out.printf("clazz1 hashCode:%s%n", clazz1.hashCode());
        System.out.printf("clazz2 hashCode:%s%n", clazz2.hashCode());
        System.out.printf("判断同一个类加载器加载同一个对象，class是否相同:%s%n", clazz1 == clazz2);
        System.out.printf("获取clazz1的类加载器:%s%n", clazz1.getClassLoader());

        // 重新创建一个自定义类加载器
        CustomClassLoader customClassLoader2 = new CustomClassLoader(path);

        // 使用不同类加载器加载UserDo
        Class<?> clazz3 = customClassLoader2.loadClass("demo3.UserDo");
        System.out.printf("clazz3 hashCode:%s%n", clazz3.hashCode());
        System.out.printf("判断不同类加载器加载同一个对象，class是否相同:%s%n", clazz1 == clazz3);
        System.out.printf("获取clazz3的类加载器:%s%n", clazz1.getClassLoader());
    }

}

执行结果：

注意：被两个类加载器加载同一个类，JVM不认为是相同的类。

加密解密类加载器

可以通过取反操作或者DES对称秘钥进行加密解密

EncrptUtils.java

java 复制代码 
package demo4;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 取反加密工具
 *
 * @author Anna.
 * @date 2024/4/5 17:36
 */
public class EncrptUtils {

    /**
     * 文件字节取反加密
     *
     * @param src  原路径
     * @param dest 目标路径
     * @return void
     * @author Anna.
     * @date 2024/4/5 17:39
     */
    public static void inversion(File src, File dest) throws IOException {
        try (FileInputStream is = new FileInputStream(src); FileOutputStream baos = new FileOutputStream(dest)) {
            int temp = -1;
            while ((temp = is.read()) != -1) {
                // 取反
                baos.write(temp ^ 0xff);
            }
        } catch (Exception e) {
            throw e;
        }
    }
}

DecrptClassLoader.java

java 复制代码 
package demo4;

import java.io.*;

/**
 * 自定义解密类加载器
 *
 * @author Anna.
 * @date 2024/4/5 16:07
 */
public class DecrptClassLoader extends ClassLoader {

    /**
     * 定义一个加载根路径
     */
    private String rootDir;

    public DecrptClassLoader(String rootDir) {
        this.rootDir = rootDir;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 加载该类是否已经加载到命名空间
        Class<?> clazz = findLoadedClass(name);
        if (clazz != null) {
            return clazz;
        }

        // 尝试自己加载类
        byte[] classData;
        try {
            classData = getClassData(name);
        } catch (IOException e) {
            throw new ClassNotFoundException();
        }

        // 如果自己也加载不到该类，则抛出异常
        if (classData == null) {
            throw new ClassNotFoundException();
        }

        // 调用defineClass()导入类型到方法区
        clazz = defineClass(name, classData, 0, classData.length);

        return clazz;
    }

    /**
     * 根据路径读取.class文件
     *
     * @param name
     * @return byte[]
     * @author Anna.
     * @date 2024/4/5 16:24
     */
    private byte[] getClassData(String name) throws IOException {
        // 将包路径转换为类路径
        String path = rootDir + File.separator + name.replace(".", File.separator) + ".class";
        // try-with-resources
        try (InputStream is = new FileInputStream(path); ByteArrayOutputStream baos = new ByteArrayOutputStream();) {
            // 使用字节流读取class文件 字节取反
            int temp = -1;
            while ((temp = is.read()) != -1) {
                // 字节取反
                baos.write(temp ^ 0xff);
            }
            return baos.toByteArray();
        }
    }
}

ClassLoadDemo.java

java 复制代码 
package demo4;

import java.io.File;
import java.io.IOException;

/**
 * 自定义解密类加载器
 * * 1 加密UserDo.class文件
 * * 2 使用上一案例中类加载器加载加密后的class
 * * 3 使用解密类加载器加载
 *
 * @author Anna.
 * @date 2024/4/5 17:36
 */
public class ClassLoadDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1 加密.class文件
        EncrptUtils.inversion(new File("D://demo3/UserDo.class"), new File("D://temp/demo3/UserDo.class"));

        // 获取根路径
        String path = "D:/temp";

        // 2 使用上一案例中类加载器加载加密后的class
        // 获取自定义类加载器    报错ClassNotFoundException
//        CustomClassLoader customClassLoader = new CustomClassLoader(path);
//        Class<?> clazz1 = customClassLoader.loadClass("demo3.UserDo");

        // 3 使用解密类加载器加载
        DecrptClassLoader decrptClassLoader = new DecrptClassLoader(path);
        Class<?> clazz2 = decrptClassLoader.loadClass("demo3.UserDo");
        System.out.printf("获取clazz3的类加载器:%s%n", clazz2.getClassLoader());
    }
}

执行结果：

gitee源码

git clone https://gitee.com/dchh/JavaStudyWorkSpaces.git

相关推荐
龙图:会赢的1 分钟前
[C语言]--编译和链接
c语言·开发语言
IT学长编程1 小时前
计算机毕业设计 玩具租赁系统的设计与实现 Java实战项目 附源码+文档+视频讲解
java·spring boot·毕业设计·课程设计·毕业论文·计算机毕业设计选题·玩具租赁系统
莹雨潇潇1 小时前
Docker 快速入门（Ubuntu版）
java·前端·docker·容器
杨哥带你写代码1 小时前
足球青训俱乐部管理：Spring Boot技术驱动
java·spring boot·后端
XKSYA(小巢校长)1 小时前
NatGo我的世界联机篇
开发语言·php
Cons.W2 小时前
Codeforces Round 975 (Div. 1) C. Tree Pruning
c语言·开发语言·剪枝
憧憬成为原神糕手2 小时前
c++_ 多态
开发语言·c++
VBA63372 小时前
VBA信息获取与处理第三个专题第三节：工作薄在空闲后自动关闭
开发语言
郭二哈2 小时前
C++——模板进阶、继承
java·服务器·c++
A尘埃2 小时前
SpringBoot的数据访问
java·spring boot·后端
热门推荐
01分享几个惊艳的 Three.js 个人站点02【经验分享】Ubuntu22.04安装微信(linux官方版)032024年高教社杯数学建模国赛C题超详细解题思路分析04组基轨迹建模 GBTM的介绍与实现（Stata 或 R）05安卓系列机型永久去除data分区加密 详细步骤解析06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07CTF网络安全大赛简单的web抓包题目：HEADache08Ubuntu24.04安装中文输入法09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10springer 在线投稿编译踩坑