【Java】一文讲解Java类加载机制

Java 类加载机制是 Java 运行时的核心组成部分,负责在程序运行过程中动态加载和连接类文件,并将其转换为可执行代码。理解类加载机制,能更容易理解你一行行敲下的Java代码是如何在JVM虚拟机上运行起来。并且理解类加载机制之后,我们也能掌握如何自定义类加载器,如何做热更新等。

// 准备好了吗,要开始咯!(下图需要离远点看)
java

一、JVM如何启动

JVM启动

启动过程如下:

  • 配置JVM装载环境
    • 查找JVM.dll文件
    • 装载JVM.dll文件
  • 解析虚拟机参数
    • 参数解析
    • 参数验证
  • 设置线程栈大小
  • 执行main方法(jdk源码中java.c的JavaMain方法)
    • 创建JVM实例
    • 加载主类class(调用jvm的java层代码的loadClass)
    • 查找main方法
    • 执行main方法

二、类加载器

  1. 引导类加载器(Bootstrap ClassLoader)

加载路径:sun.boot.class.path

引导类加载器主要负责加载最最核心的java类型。 这些类库位于jre目录的lib目录下**. 比如:rt.jar, charset.jar等,

引导类加载器是由C++帮我们实现的, 然后c++语言会通过一个Launcher类将扩展类加载器(ExtClassLoader)和应用程序类加载器(AppClassLoader)构造出来, 并且把他们之间的关系构建好.

  1. 扩展类加载器(Ext ClassLoader)

加载路径:java.ext.dirs

扩展类加载器主要是用来加载扩展的jar包。 加载jar的目录位于jre目录的lib/ext扩展目录中的jar包

  1. 应用程序类加载器(App ClassLoader)

加载路径:java.class.path

主要是用来加载用户自己写的类的。 负责加载classPath路径下的类包

  1. 自定义类加载器

负责加载用户自定义路径下的类包

三、类加载过程

类加载过程

  1. 加载(Loading):把class文件加载到内存
  2. 链接(Linking)
    1. 验证(Verification):校验文件是否符合class规范
    2. 准备(Preparation):静态变量赋默认值
    3. 解析(Resolution):把类型方法属性等解析为直接引用
  3. 初始化(Initializing):静态变量赋初始值,调用静态代码块
  4. 使用
  5. 卸载

类加载机制:

  • 全盘委托机制:当ClassLoader加载类时,除非显示指定另一个ClassLoader,否则该类的引用和依赖也由这个ClassLoader载入
  • 双亲委派机制:ClassLoader在加载类时,会首先让父类去加载,只有当父类无法加载的时候,才会由子类来加载

四、双亲委派原则

双亲委派原则是指ClassLoader在类加载时,会自下而上询问父类是否加载,如果没有加载先由父类加载,父类加载不到再由其子类自上而下加载

双亲委派

双亲委派的好处是安全

相关源码:

// ClassLoader.class
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;
    }
}

Class.forName和ClassLoader.loadClass的区别

  1. class.forName()将类的.class文件加载到jvm中后,还会对类进行解释,执行类中的static块。也可通过传参指定是否初始化
  2. loadClass只干一件事情,就是将.class文件加载到jvm中,不会执行static中的内容,只有在newInstance才会去执行static块

jvm

五、类加载应用:热更新

1. ClassLoader热更新

自定义ClassLoader的子类(打破双亲委派原则),使用ClassLoader的defineClass即可加载新的byte数组覆盖原有的字节码

  1. 自定义ClassLoader
  2. 读取要热更的class文件并转换成byte数组
  3. 重写findClass方法并调用ClassLoader的defineClass

2. Instrument热更新

Java Instrumentation 是 JDK5 之后提供接口。使用这组接口,我们可以获取到正在运行 JVM 相关信息,使用这些信息我们构建相关监控程序检测 JVM。另外, 最重要我们可以替换修改类的,这样就实现了热更新。

Instrumentation提供premain和agentmain两种方式

1. premain方式

这种方式需要在虚拟机参数指定 Instrumentation 程序。使用方式如下:

java -javaagent:jar Instrumentation_jar -jar xxx.jar

并且在执行java的main方法之前,会先执行在mainfest中指定的premainClass中的类里的premain方法(需要提前定一个用于热更新的类,并加上premain方法)。之后就可以通过Instrumentation接口调用其中的redefineClasses方法来热更新类了

应用示例-热更新实现:

  1. 新建reload工程,定义热更新工具类ClassReloadUtils,并添加premain方法,缓存JVM层传进来的Instrumentation接口的实例
private static Instrumentation inst = null;
private static final Object LOCK = new Object();
private ClassReloadUtils() {
}
/**
 * 此方法由JAVA虚拟机调用
 * 
 * @param agentArgs
 * @param ins
 */
public static void premain(String agentArgs, Instrumentation ins) {
    synchronized (LOCK) {
        if (inst == null) {
            inst = ins;
            StringBuilder builder = new StringBuilder("[");
            builder.append(new Timestamp(System.currentTimeMillis()));
            builder.append("]-");
            builder.append(CLASS_RELOAD_OPEN_TIPS);
            System.out.println(builder.toString());
        }
    }
}
  1. reload的pom文件添加Premain-Class标签指定premain方法所在的类,并指定Can-Redefine-Classes为true
<build>
    <finalName>mmo.reload</finalName>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.3.1</version>
            <configuration>
                <archive>
                    <manifestEntries>
                        <Premain-Class>com.xxx.ClassReloadUtils</Premain-Class>
                        <Can-Redefine-Classes>true</Can-Redefine-Classes>
                    </manifestEntries>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>

  1. 用ClassLoader加载热更类,并把要热更的class文件读到byte数组,创建ClassDefinition类
String className = classFile.getName();
className = className.replace(CLASS_EXT, "");
// loadClass
Class<?> clasz = classLoader.loadClass(className);
byte[] bs = FileUtils.toByteArray(classFile);
return new ClassDefinition(clasz, bs);
  1. 使用启动时缓存的Instrumentation接口调用redefineClasses,并传入要热更的ClassDefinition类,完成热更
ClassDefinition[] definitions = classDefinitions.toArray(new ClassDefinition[classDefinitions.size()]);
try {
    inst.redefineClasses(definitions);
} catch (Exception e) {
    return ReloadResult.failed(String.format(CLASS_RELOAD_FAILED, e.getMessage()));
}

2. agentmain方式

arthas使用agentmain加attach方式实现动态监控以及动态修改字节码

不同于premain方式,agentmain允许在JVM启动之后进行代理,它的实现方式和premain类似,先定义一个用于热更新的类,并添加agentmain方法。接着读取外部传入 class 文件,调用?Instrumentation#redefineClasses,这个方法将会使用新 class 替换当前正在运行的 class,这样我们就完成了类的修改。

步骤如下:

  1. 创建热更代理工程,定义热更工具类AgentMain
  2. 类似premain方式,pom文件中添加指定工具类已经定义为可重定义class为true
<!--指定 class 名字-->
<Agent-Class>
    com.andyxh.AgentMain
</Agent-Class>
<Can-Redefine-Classes>
    true
</Can-Redefine-Classes>
  1. 在热更工具类AgentMain实现agentmain方法,在其中调用Instrumentation.redefineClasses完成热更逻辑

至此热更逻辑已经结束,后面则需要利用JVM提供的Attach功能把代理动态加进去

  1. 通过JVM的attach动态添加agent
System.out.println("当前热更新工具 jar 路径为 "+jarPath);
VirtualMachine vm = VirtualMachine.attach(pid);//7997是待绑定的jvm进程的pid号
// 运行最终 AgentMain 中方法
vm.loadAgent(jarPath, classPath);

其中的Attach原理:Attach API 位于 tools.jar 包,可以用来连接目标 JVM。Attach API 非常简单,内部只有两个主要的类,VirtualMachineVirtualMachineDescriptor

VirtualMachine?代表一个 JVM 实例, 使用它提供?attach?方法,我们就可以连接上目标 JVM。

 VirtualMachine vm = VirtualMachine.attach(pid);

VirtualMachineDescriptor?则是一个描述虚拟机的容器类,通过该实例我们可以获取到 JVM PID(进程 ID),该实例主要通过?VirtualMachine#list?方法获取。

for (VirtualMachineDescriptor descriptor : VirtualMachine.list()){
    System.out.println(descriptor.id());
}

java

3. 热更新的局限性

  • premain和agentmain均在类文件加载后,因此不能重新定义一个不存在类
  • 热更的类和旧的类继承的父类必须相同
  • 热更的类和旧的类继承的接口必须相同
  • 热更的类和旧的类的访问修饰符,字段必须相同
  • 热更的类和旧的类新增或删除的方法必须是private static/final修饰
  • 热更的类可以修改方法体

更多技术干货,欢迎关注我

qrcode