Java 类加载机制是 Java 运行时的核心组成部分，负责在程序运行过程中动态加载和连接类文件，并将其转换为可执行代码。理解类加载机制，能更容易理解你一行行敲下的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)构造出来, 并且把他们之间的关系构建好.

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

加载路径：java.ext.dirs

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

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

加载路径：java.class.path

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

4. 自定义类加载器

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

三、类加载过程

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块

五、类加载应用：热更新

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());
		}
	}
}

2. 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>

3. 用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);

4. 使用启动时缓存的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>

3. 在热更工具类AgentMain实现agentmain方法，在其中调用Instrumentation.redefineClasses完成热更逻辑

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

4. 通过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 非常简单，内部只有两个主要的类，VirtualMachine 与 VirtualMachineDescriptor。

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());
}

3. 热更新的局限性

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

---

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