前言

大家应该都知道，当一个Java项目启动的时候，JVM会找到main方法，根据对象之间的调用来对class文件和所引用的jar包中的class文件进行加载(其步骤分为加载、验证、准备、解析、初始化、使用和卸载)，方法区中开辟内存来存储类的运行时数据结构(包括静态变量、静态方法、常量池、类结构等)，同时在堆中生成相应的Class对象指向方法区中对应的类运行时数据结构。

用最简单的一句话来概括，类加载的过程就是JVM根据所需的class文件的路径，通过IO流的方式来读取class字节码文件，并通过一系列解析初始化等步骤来注入到内存。 java中的类加载器有：BootstrapClassLoader(最上层)、ExtClassLoader、AppClassLoader、以及用户自定义的ClassLoader(最下层)。JVM对于不同种类的jar包(或class文件)，会有不同种类的类加载器进行加载。

对应关系如下：

BootstrapClassLoader  用于加载JVM运行所需要的类：

JAVA_HOME/jre/lib/resources.jar:

JAVA_HOME/jre/lib/rt.jar:

JAVA_HOME/jre/lib/sunrsasign.jar:

JAVA_HOME/jre/lib/jsse.jar:

JAVA_HOME/jre/lib/jce.jar:

JAVA_HOME/jre/lib/charsets.jar:

JAVA_HOME/jre/lib/jfr.jar:

JAVA_HOME/jre/classes

ExtClassLoader 用于加载扩展类：

../Java/Extensions:

../JAVA_HOME/jre/lib/ext:　　　　../Library/Java/Extensions:/Network/Library/Java/Extensions:

../System/Library/Java/Extensions:

../lib/java

AppClassLoader 用于加载我们项目中ClassPath下所创建的类和jar包中引用的类。

整个类加载，是通过一种叫做双亲委派的机制来进行加载。

举例来说，一个类被最下层的加载器(用户自定义ClassLoader)进行加载，此加载器首先会调用上一层的加载器(AppClassLoader)进行加载，而AppClassLoader会继续转交给上层(ExtClassLoader)的加载器进行加载，直到BootstrapClassLoader。  如果BootstrapClassLoader所加载的类路径找不到此类，那么才会交给下一层的加载器(ExtClassLoader)进行加载，如果找不到此类，继续交给下一层(AppClassLoader)进行加载。以此类推，如果用户自定义的ClassLoader也找不到此类，那么程序就会抛出一个ClassNotFoundError。

整个加载过程图示如下：

(图片引用自：https://www.cnblogs.com/xing901022/p/4574961.html)

类加载源的源码跟踪如下(在此对源码进行了适当的简化)，读者可以点入源码进行查看：

package java.lang.ClassLoader;

import ....

protected Class> loadClass(String name, boolean resolve)

throws ClassNotFoundException

{

synchronized (getClassLoadingLock(name)) {

// First，在虚拟机内存中查找是否已经加载过此类...类缓存的主要问题所在！！！

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) {

//调用此类加载器所实现的findClass方法进行加载

c = findClass(name);

}

}

if (resolve) {

resolveClass(c);

}

return c;

}

}

在源码中可以完全领略到双亲委派机制的过程，其中最重要的三句代码已经进行了标注：

findLoadedClass(在虚拟机内存中查找是否已经加载过此类...类缓存的主要问题所在！！！)

parent.loadClass(先让上一层加载器进行加载)

findClass(调用此类加载器所实现的findClass方法进行加载)

如果用户需要自定义加载器，加载自己指定路径的class文件，需要继承ClassLoader，并实现findClass(String name)方法。举例如下：

package com.linuxidc.utils;

import java.io.ByteArrayOutputStream;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

public class ServiceClassLoader extends ClassLoader{

private String classPath;

public ServiceClassLoader(String classPath) {

this.classPath = classPath;

}

/**

* 重写父类的findClass 方法。 父类的loadClass会调用此方法

*/

@Override

protected Class> findClass(String name) throws ClassNotFoundException {

Class> c = null;

byte[] classData = getClassData(name);

if (classData!=null) {

c = defineClass(name, classData, 0, classData.length);

}else {

throw new ClassNotFoundException();

}

return c;

}

// 将class文件通过IO流读取，转化为字节数组

private byte[] getClassData(String name) {

String path = classPath + "/"+ name.replace('.', '/') + ".class";

InputStream iStream = null;

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

try {

iStream = new FileInputStream(path);

byte[] buffer = new byte[1024];

int temp = 0;

while ((temp = iStream.read(buffer))!=-1) {

byteArrayOutputStream.write(buffer, 0, temp);

}

if (byteArrayOutputStream!=null) {

return byteArrayOutputStream.toByteArray();

}

} catch (Exception e) {

e.printStackTrace();

}finally {

try {

if (iStream!=null) {

iStream.close();

}

} catch (IOException e) {

e.printStackTrace();

}

try {

if (byteArrayOutputStream!=null) {

byteArrayOutputStream.close();

}

} catch (IOException e) {

e.printStackTrace();

}

}

return null;

}

}

对类加载器的使用代码如下：

ServiceClassLoader serviceClassLoader = new ServiceClassLoader("c:\myclass");

Czlass> c = ServiceClassLoader.loadClass("com.linuxidc.service.Myclass");

如果 用同一个 ServiceClassLoader 对象去加载同一个Class文件多次，每次加载后的Class对象为同一个！ 然而如果new不同的自定义ClassLoader去加载同一个Class文件，则每次会返回不同的Class对象。

注意： 不能将所要加载的Class文件放到classpath目录及其任何子目录下，否则会被AppClassLoader优先加载 (这是由于类加载采用双亲委派机制，同时AppClassLoader可以加载所有在classpath下的class文件)， 每次都是同一个AppClassLoader进行加载，因此会出现类缓存问题。

这样就解决了通常在JVM类加载时，直接使用反射出现的类缓存的问题。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对脚本之家的支持。