JVM双亲委派模型知识详细总结

JVM双亲委派模型知识详细总结

一、简介

除了顶层的启动类加载器（Bootstrap ClassLoader）外，其余的类加载器都应当有自己的上层加载器，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给上层的加载器，如果上层类加载器还存在其上层类加载器，则进一步向上委托，依次递归，直到请求最终到达顶层的启动类加载器，从顶层类加载器开始，如果类加载器根据类的全限定名查询到已经加载过这个类，就成功返回加载过的此类信息，倘若加载器未加载过此类，则原路返回给下层加载器继续重复此过程，直到最先加载此类的加载器所有上层加载器都未加载过此类后，此类加载器才会尝试自己去加载，这便是双亲委派模式。

举个栗子：

假如你是某个企业员工，你写了一份方案希望得到执行，首先你得拿给你的经理去审批吧，经理说这个事情他做不了主，于是经理就拿给总经理看，总经理也做不了主，就给董事长看，然后董事长看了看，也看不明白于是让总经理自己拿主意吧，总经理仔细一看，这个方案之前公司已经做过了，于是让经理去告诉那个员工不用做了，直接用那个做过的方案吧。

二、双亲委派的意义

采用双亲委派模式的是好处是java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关系可以避免类的重复加载，当上层类加载器已经加载了该类时，就没有必要下层的ClassLoader再加载一次。

其次是考虑到安全因素，jdk中定义的类不会被随意替换，假设我们在classpath路径下自定义一个名为java.lang.Integer的类，通过双亲委托模式传递到启动类加载器，而启动类加载器通过索引发现同全限定名的类已被加载，并不会重新加载网络传递的过来的java.lang.Integer，而直接返回已加载过的Integer.class，那么你所定义的类就不会被加载，这样便可以防止核心API库被随意篡改。

如：

package java.lang;

public class Integer {

public void print(){

System.out.println("this is Integer.");

}

public static void main(String[] args) {

new Integer().print();

}

}

执行main方法后输出如下：

三、JVM提供的类加载器

启动类加载器（BootstrapClassLoader）:由jvm负责管理，主要负责加载核心的类库(**rt.jar，也就是java.lang.***等)，并构造和启动ExtClassLoader和APPClassLoader。

扩展类加载器（ExtClassLoader）：主要负责加载jre/lib/ext**目录下的一些扩展的jar。

应用类加载器（AppClassLoader）：主要负责加载classpath下jar包和应用程序的主函数类。

如果当前类加载器加载的类引用了其它类，那么也会通过递归的方式先对其所有引用进行加载。

四、执行类加载的五种方式

认识了这三种类加载器，接下来我们看看类加载的五种方式。

1.通过命令行使用java命令启动应用时由JVM初始化加载含有main()方法的主类。

2.使用new关键字初始化一个对象时

3.通过类对应的Class对象的newInstance()方法

4.通过Class.forName(name)方法动态加载

5.通过ClassLoader.loadClass(name)方法动态加载

五、自定义类加载器

java系统为我们提供的三种类加载器，还给出了他们的层次关系图，最下面就是自定义类加载器，那么我们如何自己定义类加载器呢？这主要有两种方式

（1）遵守双亲委派模型：继承ClassLoader，重写findClass方法。

通常我们推荐采用此方式自定义类加载器，最大程度上的遵守双亲委派模型。

findClass(name)查找具有指定全限定名的类。此方法用于遵循加载类的委托模型的类装入器实现重写，并将在检查请求类的父类装入器之后由loadClass方法调用。如果该类没有被加载过且其class文件读取不到则抛出ClassNotFoundException异常。

protected Class> findClass(String name) throws ClassNotFoundException {

throw new ClassNotFoundException(name);

}

其实现例子：

package com.aliencat.javabase.classloader;

public class MyClassLoader extends ClassLoader{

protected Class> findClass(String name) throws ClassNotFoundException {

switch (name){

case "java.lang.Integer":return Double.class;

case "com.aliencat.javabase.classloader.LoaderDemo" : return loadClassFromDisk(name);

}

throw new ClassNotFoundException(name);

}

//从calsspath下加载类的字节码文件

public byte[] loadClassFromDisk(String name) {

String classPathRoot = Thread.currentThread().getContextClassLoader().getResource("").getPath();

classPathRoot = classPathRoot.substring(1);

String filePath = classPathRoot + name.replace(".","/") + ".class";

try(InputStream in = new FileInputStream(filePath) ;

ByteOutputStream stream = new ByteOutputStream()) {

byte[] buff = new byte[1024];

for(int num = 0; (num=in.read(buff)) != -1;){

stream.write(buff,0,num);

}

return stream.toByteArray();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

return null;

}

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

Class clzz = new MyClassLoader().loadClass("com.aliencat.javabase.classloader.LoaderDemo");

System.out.println(clzz);

clzz = new MyChttp://lassLoader().loadClass("java.lang.Integer");

System.out.println(clzz);

clzz = new MyClassLoader().loadClass("java.lang.String");

System.out.println(clzz);

clzz = new MyClassLoader().loadClass("java.lang.xxxxx");

System.out.println(clzz);

}

}

输出如下：

（2）破坏双亲委派模型：继承ClassLoader,重写loadClass方法。

我们先来看下loadClass方法的源码是怎样的：

protected Class> loadClass(String name, boolean resolve)

throws ClassNotFoundException

{

synchronized (getClassLoadingLock(name)) {

// 首先，在当前加载器加载过的类中检查这个类有没有被加载过

Class> c = findLoadedClass(name);

if (c == null) {

long t0 = System.nanoTime();

try {

if (parent != null) {

//存在上层类加载器，则让上层取执行loadClass方法

c = parent.loadClass(name, false);

} else {

//让BootstrapClass类加载器去查找该类

c = findBootstrapClassOrNull(name);

}

} catch (ClassNotFoundException e) {

// 上层类加载器抛出了ClassNotFoundException 则不进行处理

}

if (c == null) {

long t1 = System.nanoTime();

// 如果上层类加载器都没有找到

// 那么这个类加载器自己去找

// 如果找到了，则将resolve置为true

c = findClass(name);

// 这是定义类加载器；记录统计数据

sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);

sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);

sun.misc.PerfCounter.getFindClasses().increment();

}

}

if (resolve) {

//解析此类的信息

resolveClass(c);

}

return c;

}

}

示例如下：

public class MyClassLoader extends ClassLoader {

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

Class clzz = new MyClassLoader().loadClass("com.aliencat.javabase.classloader.ClassTest");

System.out.println(clzz);

clzz = new MyClassLoader().loadClass("java.lang.Double");

System.out.println(clzz);

clzz = new MyClassLoader().loadClass("java.lang.String");

System.out.println(clzz);

}

protected Class> findClass(String name) throws ClassNotFoundException {

switch (name) {

case "java.lang.Double":

return Integer.class;

case "java.lang.Object": //如果去掉此项，则破坏双亲委任的情况下会报找不到Object的NoClassDefFoundError异常

return Object.class;

case "com.aliencat.javabase.classloader.ClassTest":

byte[] bytes = loadClassFromDisk(name);

if(bytes != null){

return defineClass(name,bytes,0,bytes.length);

}else {

return null;

}

}

throw new ClassNotFoundException(name);

}

//从calsspath下加载类的字节码文件

public byte[] loadClassFromDisk(String name) {

String classPathRoot = Thread.currentThread().getContextClassLoader().getResource("").getPath();

classPathRoot = classPathRoot.substring(1);

String filePath = classPathRoot + name.replace(".","/") + ".class";

try(InputStream in = new FileInputStream(filePath) ;

ByteOutputStream stream = new ByteOutputStream()) {

byte[] buff = new byte[1024];

for(int num = 0; (num=in.read(buff)) != -1;){

stream.write(buff,0,num);

}

return stream.toByteArray();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

return null;

}

protected Class> loadClass(String name, boolean resolve)

throws ClassNotFoundException {

synchronized (LoaderDemo.class) {

// 首先，在当前加载器加载过的类中检查这个类有没有被加载过

Class> c = findLoadedClass(name);

if (c == null) {

//没加载过的话就去磁盘对应路径下去找

c = findClass(name);

}

return c;

}

}

}

class ClassTest{

}

输出如下：

所以破坏双亲委托的方法简单来说就是通过继承ClassLoader重写loadClhttp://ass方法，去掉其中委托给上级加载类的相关逻辑然后实现自定义的加载类的findClass逻辑。（另外你可以试试把ClassTehttp://st替换String的类名是什么效果哦，我就不演示了）

六、总结

Q:前面说了一堆双亲委托的好处，那么为什么要破坏双亲委托呢？

A:因为在某些情况下父类加载器需要委托子类加载器去加载class文件。受到加载范围的限制，父类加载器无法加载到需要的文件，以JDBC接口为例，由于JDBC接口定义在jdk当中的，而其实现由各个数据库的服务商来提供，比如mysql的就写了MySQL-Connector，那么问题就来了，JDBC接口由启动类加载器加载，而JDBC的实现是由服务商提供的，并不在启动类加载器的加载目录下，在不破坏双亲委派的情况下，启动类加载器下层的类加载器要加载JDBC则必然会返回启动类加载器中已经加载过的接口，那么服务商提供的JDBC就不会被加载，所以需要自定义类加载器破坏双亲委派拿到服务商实现的JDBC接口，这里仅仅是举了破坏双亲委派的其中一个情况，类似的还有tomcat。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。