一、简介
除了顶层的启动类加载器（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 MyClassLoader().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重写loadClass方法，去掉其中委托给上级加载类的相关逻辑然后实现自定义的加载类的findClass逻辑。（另外你可以试试把ClassTest替换String的类名是什么效果哦，我就不演示了）
六、总结
Q:前面说了一堆双亲委托的好处，那么为什么要破坏双亲委托呢？
A:因为在某些情况下父类加载器需要委托子类加载器去加载class文件。受到加载范围的限制，父类加载器无法加载到需要的文件，以JDBC接口为例，由于JDBC接口定义在jdk当中的，而其实现由各个数据库的服务商来提供，比如mysql的就写了MySQL-Connector，那么问题就来了，JDBC接口由启动类加载器加载，而JDBC的实现是由服务商提供的，并不在启动类加载器的加载目录下，在不破坏双亲委派的情况下，启动类加载器下层的类加载器要加载JDBC则必然会返回启动类加载器中已经加载过的接口，那么服务商提供的JDBC就不会被加载，所以需要自定义类加载器破坏双亲委派拿到服务商实现的JDBC接口，这里仅仅是举了破坏双亲委派的其中一个情况，类似的还有tomcat。
到此这篇关于JVM双亲委派模型知识详细总结的文章就介绍到这了,更多相关JVM双亲委派模型内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！