ClassLoader加实例解析
一、类加载器及双亲委派机制介绍
在JVM中,一个类被加载到虚拟机这个过程包括有3个步骤,即加载、连接和初始化。而加载这个过程,就是由类加载器ClassLoader
进行加载的,类加载器天生就负责这个职责。
Java本身给我们提供了几种类型的类加载器,启动类加载器Bootstrap ClassLoader
、扩展类加载器Extension ClassLoader
、应用类加载器App ClassLoader
,除了上面3种,我们也可以定义我们自己的类加载器,此时我们只需要继承ClassLoader
类,重写其findClass()
方法即可。
当然,有时候,你以为的并不是你以为的,当我们用自定义类加载器去加载类路径ClassPath
下某个class
文件时,然后调用该Class
对象的getClassLoader()
方法时,我们会发现,加载该类的类加载器,并不是我们自定义的加载器,至于为什么?下文将会讲到。 下图是JVM类加载器机制
-
1、启动类加载器
Bootstrap ClassLoader
启动类加载器,负责
%JRE_HOME/lib/
目录下的相关类文件,比如rt.jar
、tools.jar
等等,比如说我们的String
类存放在rt.jar
中,器加载器就是Bootstrap ClassLoader
-
2、扩展类加载器
Extension ClassLoader
扩展类加载器,负责
%JRE_HOME/lib/ext
目录下的相关类文件,比如rt.jar
、tools.jar
等等 -
3、应用类加载器
App ClassLoader
应用类加载器,负责加载应用程序类路径下的
class
文件。
说到类路径的问题,我们解释一下,java的类路径指的是我们配置的系统环境变量的值:CLASSPATH
,但又不局限于这个值。小编先打印下我们本地的classpath
的值:
.;D:\development\jdk\lib\dt.jar;D:\development\jdk\lib\tools.jar;
你会发现,这根本就不是我们用的开发工具中的目录呀,那么JVM
是怎么加载到我们在eclipse
上编写的类呢?答案是eclipse
已经帮我们弄好了一切。
下边我们举个例子,看下String
类的类加载器是什么:
System.out.println(String.class.getClassLoader());
上面这句代码输出null
。为什么呢?因为如果一个类是被Bootstrap ClassLoader
或者Extension ClassLoader
加载时,getClassLoader()
规定输出null
。又因为String
类存在rt.jar
中,将会被Bootstrap ClassLoader
加载,所以输出null
。
谈及类加载器,我们不得不说类的双亲委派机制,一句话总结双亲委派机制,小编总结成一句话:
如果自定义加载器P有父加载器P1,那么在加载前就将加载任务委派给其父亲P1,如果P1也存在父加载器P2,那么将加载任务委派给P2,如果最顶层的Bootstrap ClassLoader还加载不到,那么就再逆着顺序加载,直到类被加载到~~
二、ClassLoader
类特性介绍
-
1、每一个
因此,我们总是能通过Class
实例都包含一个ClassLoader
引用Class
对象的getClassLoader()
方法获取其类加载器。当然了,就如上面说的,如果一个类是被Bootstrap ClassLoader
或者Extension ClassLoader
加载时,getClassLoader()
规定输出null
。这是一个需要我们注意的点。 -
2、对于数组类型
[]
对象,它们不是由类加载器ClassLoader
去进行加载的,而是Java虚拟机根据需要自动创建的。我们通过数组类型的Class
对象的getClassLoader()
方法返回的值跟数组里边元素所使用的的类加载器一样,但如果数组元素为原始类型int
啥的,则getClassLoader()
方法将返回null
// sun.misc.Launcher$AppClassLoader@73d16e93 ClassLoaderTest[] array = new ClassLoaderTest[5]; System.out.println(array.getClass().getClassLoader()); // null int[] intArray = new int[3]; System.out.println(intArray.getClass().getClassLoader()); 复制代码
-
3、我们可以通过继承
ClassLoader
类,来实现自己的类加载器
/**
* 自定义类加载器
* @Author jiawei huang
* @Since 2019年8月7日
* @Version 1.0
*/
public class MyClassLoader extends ClassLoader {
// 如果我们从其他地方进行加载,我们可以指定路径
private String classpath;
public MyClassLoader(String classPath) {
classpath = classPath;
}
public MyClassLoader() {
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
Class clazz = null;
// 获取该class文件字节码数组
byte[] classData = getClassData();
if (classData != null) {
// 将class的字节码数组转换成Class类的实例
clazz = defineClass(name, classData, 0, classData.length);
}
return clazz;
}
private byte[] getClassData() {
byte[] bytes = null;
File file = new File(classpath);
if (file.exists()) {
// 从文件中读取class字节数据
FileInputStream in = null;
ByteArrayOutputStream out = null;
try {
in = new FileInputStream(file);
out = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int size = 0;
while ((size = in.read(buffer)) != -1) {
out.write(buffer, 0, size);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
bytes = out.toByteArray();
}
return bytes;
}
}
复制代码
假设我们在ex
包路径下有个Main.java
,看看我们下面的输出:
A.java
MyClassLoader loader = new MyClassLoader();
Class<?> clazzClass = loader.loadClass("ex.Main");
// 1
System.out.println(clazzClass.getClassLoader());
复制代码
上面1
处将输出sun.misc.Launcher$AppClassLoader@73d16e93
,我们可能会问,明明我是用自己的类加载器去加载ex.Main
的呀,为什么却输出AppClassLoader
这个类加载器呢?其实这就是双亲委派机制,MyClassLoader
把加载任务给到其父加载器App ClassLoader
,刚好ex.Main
又处于类路径下,所以App ClassLoader
加载之后就直接返回了。
-
4、一个类整个生命周期只会被加载一次,有且仅有一次
-
5、支持并行加载的加载器称为并行加载器,但前提是,我们必须在自定义加载器的初始化时,调用
ClassLoader.registerAsParallelCapable();
方法注册自己,怎么做呢?我们看看URLClassLoader
的源码。
static {
// 注册自己
ClassLoader.registerAsParallelCapable();
}
复制代码
- 6、在委托模型不是严格分层的情况下,自定义类加载器需要具有并行能力,否则类加载可能导致死锁,因为加载器锁在类加载过程中一直持有。
详情我们看下ClassLoader
中loadClass()
方法源码:
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
// 这里有个锁
synchronized (getClassLoadingLock(name)) {
1、先检查这个名称的类是否已经被加载过,如果是,就不再加载了,这也印证了我们第4点说的一个类只会被加载一次
Class<?> c = findLoadedClass(name);
// 2、如果该类没有被加载,那么就进行加载
if (c == null) {
long t0 = System.nanoTime();
try {
// 3、如果存在父加载器,就进行委派,这就是双亲委派机制的原理
if (parent != null) {
c = parent.loadClass(name, false);
} else {
// 4、去`Bootstrap classloader`加载
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
// 5、如果3,4都没有加载到,那就执行我们自定义的classloader,这也是为什么我们要重写findClass方法的原因所在
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;
}
}
复制代码
- 7、我们不仅仅可以从文件系统中对类进行加载,我们还可以从网络上进行
class
文件的加载,获取byte[]
,然后通过ClassLoader
的defineClass()
将byte[]
转换成Class
对象,最后通过Class.newInstance()
即可转成Java对象啦~~~
ClassLoader loader = new NetworkClassLoader(host, port);
Object main = loader.loadClass("Main", true).newInstance();
复制代码
三、SpringBoot
中,构造器为什么要加上ClassLoader
参数?
因为初始化过程中,load()
方法需要从不同的地方去加载类文件。
protected void load(ApplicationContext context, Object[] sources) {
if (logger.isDebugEnabled()) {
logger.debug(
"Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
}
BeanDefinitionLoader loader = createBeanDefinitionLoader(
getBeanDefinitionRegistry(context), sources);
if (this.beanNameGenerator != null) {
loader.setBeanNameGenerator(this.beanNameGenerator);
}
if (this.resourceLoader != null) {
loader.setResourceLoader(this.resourceLoader);
}
if (this.environment != null) {
loader.setEnvironment(this.environment);
}
loader.load();
}
复制代码