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 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双亲委派模型内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • java虚拟机之JVM调优详解

    JVM常用命令行参数 1. 查看参数列表 虚拟机参数分为基本和扩展两类,在命令行中输入 JAVA_HOME\bin\java就可得到基本参数列表. 在命令行输入 JAVA_HOME\bin\java –X就可得到扩展参数列表. 2. 基本参数说明: -client,-server: 两种Java虚拟机启动方式,client模式启动比较快,但是性能和内存管理相对较差,server模式启动比较慢,但是运行性能比较高,windos上采用的是client模式,Linux采用server模式 -class

  • JVM的类加载过程以及双亲委派模型详解

    jvm 的主要组成部分 类加载器(ClassLoader) 运行时数据区(Runtime Data Area) 执行引擎(Execution Engine) 本地库接口(Native Interface) jvm 运行时数据区的组成 方法区: ①方法区主要用来存储已被虚拟机加载的类信息(构造器,接口定义).常量.静态变量和运行时常量池等数据. ②该区域是被线程共享的. ③方法区里有一个运行时常量池,用于存放静态编译产生的字面量和符号引用.该常量池具有动态性,也就是说常量并不一定是编译时确定,运行

  • jvm运行原理以及类加载器实例详解

    JVM运行原理 首先从".java"代码文件,编译成".class"字节码文件,然后类加载器将".class"字节码文件中的类给加载带JVM中,最后就是JVM执行写好的代码.执行过程如下图 类加载器 类加载过程 加载 -> 验证 -> 准备 -> 解析 -> 初始化 -> 使用 -> 卸载 加载 一旦JVM进程启动之后,一定会先把类加载到内存中,然后从main()方法的入口代码开始执行 public class

  • Java 汇编JVM编写jasmin程序的操作方法

    Jasmin是Java汇编语言,以文本方式来描述JVM的指令集以及Java Class的结构,Jasmin编译器可以把汇编语言转换成二进制的字节码,使JVM可以调入执行. Jasmin最初是由Jon Meyer和Troy Downing编纂<Java Virtual Machine>时设计的范例,虽然该书不再出版,但是Jasmin成为了事实上的Java汇编语言标准,并作为开源项目得到发展:http://jasmin.sourceforge.net/. Jasmin在Java class方面的处

  • JVM中ClassLoader类加载器的深入理解

    JVM的体系结构图 先来看一下JVM的体系结构,如下图: JVM的位置 JVM的位置,如下图: JVM是运行在操作系统之上的,与硬件没有直接的交互,但是可以调用底层的硬件,用JIN(Java本地接口调用底层硬件) JVM结构图中的class files文件 class files文件,是保存在我们电脑本地的字节码文件,.java文件经过编译之后,就会生成一个.class文件,这个文件就是class files所对应的字节码文件,如下图: JVM结构图中的类加载器ClassLoader的解释 类加

  • JVM常量池的深入讲解

    提示:这里咱们要说的常量池,常量池就是咱们面试中所说的常量池,谈谈你对常量池的认识?面试官一问咱们就懵逼了,你要记得你脑子中有一张图!!! 剩下的就好办了 提示:请各位大佬批评指正!! 前言 提示:学习的时候会有点头疼哦 一.Class常量池与运行时常量池 Class常量池可以理解为是Class文件中的资源仓库. Class文件中除了包含类的版本.字段.方法.接口等描述信息外,还有一项信息就是 常量池(constant pool table) ,用于存放编译期生成的各种 字面量(Literal)

  • 浅谈Java自定义类加载器及JVM自带的类加载器之间的交互关系

    JVM自带的类加载器: 其关系如下: 其中,类加载器在加载类的时候是使用了所谓的"父委托"机制.其中,除了根类加载器以外,其他的类加载器都有且只有一个父类加载器. 关于父委托机制的说明: 当生成 一个自定义的类加载器实例时,如果没有指定它的父加载器,那么系统类加载器将成为该类加载器的父类加载器 下面,自定义类加载器.自定义的类加载器必须继承java.lang.ClassLoader类 import java.io.*; public class MyClassLoader extend

  • jvm之java类加载机制和类加载器(ClassLoader)的用法

    当程序主动使用某个类时,如果该类还未被加载到内存中,则JVM会通过加载.连接.初始化3个步骤来对该类进行初始化.如果没有意外,JVM将会连续完成3个步骤,所以有时也把这个3个步骤统称为类加载或类初始化. 一.类加载过程 1.加载 加载指的是将类的class文件读入到内存,并为之创建一个java.lang.Class对象,也就是说,当程序中使用任何类时,系统都会为之建立一个java.lang.Class对象. 类的加载由类加载器完成,类加载器通常由JVM提供,这些类加载器也是前面所有程序运行的基础

  • jvm类加载器基础解析

    [类加载器简介] 类加载器(classloader)用于将类的class文件加载到JVM虚拟机.JVM有三种加载器,引导类加载器器(bootstrapclassloader).扩展类加载器(extensionsclassloader)和应用类加载器(applicationclassloader),另外还可以继承java.lang.ClassLoader类创建自定义加载器. [类加载器种类] 1.引导类加载器(BootStrap):并不是一个Java类,采用C++语言编写.内嵌在JVM内核里面,使

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

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

  • Java虚拟机之对象创建过程与类加载机制及双亲委派模型

    目录 一.对象的创建过程: 1.对象的创建过程: 2.对象的访问方式: 二.类加载机制: 2.1.加载阶段: 2.2.验证阶段: 2.3.准备阶段: 2.4.解析阶段: 2.5.初始化: 2.5.1.类的主动引用: 2.5.2.类的被动引用: 2.5.3.()方法的特点: 三.类加载器与双亲委派模型: 3.1.JVM 的类加载器: 3.2.双亲委派模型: 3.2.1.双亲委派模型的工作原理: 3.2.2.双亲委派模型的优点: 3.3.类加载器源码:loadClass() 3.4.如何破坏双亲委派

  • JVM要双亲委派的原因及如何打破它

    一.类加载器 类加载器,顾名思义就是一个可以将Java字节码加载为java.lang.Class实例的工具.这个过程包括,读取字节数组.验证.解析.初始化等.另外,它也可以加载资源,包括图像文件和配置文件. 类加载器的特点: 动态加载,无需在程序一开始运行的时候加载,而是在程序运行的过程中,动态按需加载,字节码的来源也很多,压缩包jar.war中,网络中,本地文件等.类加载器动态加载的特点为热部署,热加载做了有力支持. 全盘负责,当一个类加载器加载一个类时,这个类所依赖的.引用的其他所有类都由这

  • Java虚拟机类加载器之双亲委派机制模型案例

    1. 双亲委派模型是什么? 当某个类加载器需要加载某个.class字节码文件时,它首先把这个任务委托给它的上级类加载器,递归这个操作,如果上级的类加载器没有加载,自己才会去加载这个类. 2. 双亲委派模型的工作原理? 1.如果一个类加载器收到了类加载的请求,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去执行: 2.如果父类加载器还存在其父类加载器,则进一步向上委托,依次递归,请求最终将到达顶层的启动类加载器:(每一个层次的类加载器都是如此,因此所有的加载请求最终都应该传送到最顶

  • JVM的类加载器和双亲委派模式你了解吗

    目录 类加载器 1.启动类加载器 2.拓展类加载器 3.应用程序类加载器 4.双亲委派模式 5.自定义类加载器 5.1.使用场景 5.2.步骤 总结 类加载器 Java虚拟机设计团队有意把类加载阶段中的“通过一个类的全限定名来获取描述该类的二进制字节流”这个动作放到Java虚拟机外部去实现,以便让应用程序自己决定如何去获取所需的类.实现这个动作的代码被称为“类加载器”(ClassLoader). 对于任意一个类,都必须由加载它的类加载器和这个类本身一起共同确立其在Java虚拟机中的唯一性,每一个

  • 详解Java类加载器与双亲委派机制

    目录 引子 了解.class文件 类加载的过程 类加载器 与 双亲委派机制 ClassLoader 自定义类加载器 编写一个自定义的类加载器 为什么我们这边要打破双亲委派机制 自定义类加载器时,如何打破双亲委派机制 SPI机制 与 线程上下文类加载器 JDBC Tomcat SpringBoot Starter 尾语 引子 大家想必都有过平时开发springboot 项目的时候稍微改动一点代码,就得重启,就很烦 网上一般介绍 2种方式 spring-boot-devtools,或者通过JRebe

  • Java类加载器与双亲委派机制和线程上下文类加载器专项解读分析

    目录 一.类加载器 1.启动类加载器 2.拓展类加载器 3.应用类加载器 4.类的命名空间 二.双亲委派机制 1.类加载机制流程 2.类加载器加载顺序 3.双亲委派机制流程 4.源码分析 5.双亲委派机制优缺点 三.线程上下文类加载器 1.线程上下文类加载器(Context Classloader) 2.ServiceLoader 四.自定义类加载器 一.类加载器 类加载器就是根据类的二进制名(binary name)读取java编译器编译好的字节码文件(.class文件),并且转化生成一个ja

  • ClassLoader双亲委派模式作用详解

    目录 前言 ClassLoader的作用 ClassLoader的种类 如何实现双亲委派模式 小测试 前言 我们的面试中经常会遇到关于ClassLoader的问题,但是我们的日常开发中又没有直接编写过ClassLoader相关的代码.对于小白新手来说,可能都不知道ClassLoader是用来干嘛的,它是如何在无形当中影响我们编写的代码的? ClassLoader的作用 见名知意,ClassLoader就是类加载器,它的作用就是将我们编写的java代码加载到JVM虚拟机中.在JVM启动的时候是不会

  • Tomcat打破双亲委派机制实现隔离Web应用的方法

    目录 Tomcat类加载器的层次结构 WebAppClassLoader SharedClassLoader CatalinaClassLoader CommonClassLoader Spring的加载问题 线程上下文加载器 总结 Tomcat通过自定义类加载器WebAppClassLoader打破双亲委派,即重写了JVM的类加载器ClassLoader的findClass方法和loadClass方法,以优先加载Web应用目录下的类. Tomcat负责加载我们的Servlet类.加载Servl

随机推荐