首页 > 其他分享 >JVM学习-详解类加载器(一)

JVM学习-详解类加载器(一)

时间:2024-06-01 23:32:47浏览次数:14  
标签:name 自定义 ClassLoader 详解 JVM 方法 Class 加载

类加载器

  • 类加载器是JVM执行类加载机制的前提
ClassLoader的作用
  • ClassLoader是Java的核心组件,所有的Class都是由ClassLoader进行加载的,ClassLoader负责通过各种方式将Class信息的二进制数据流读入JVM内部,转换为一个与目标类型对应的java.lang.Class对象实例,然后交给Java虚拟机进行链接,初始化等操作,因此ClassLoader整个装载阶段,只能影响类的加载,而无法通过ClassLoader去改变类的链接和初始化行为,至于是否可以运行,由Execution Engine决定
    在这里插入图片描述
  • 类加载器最早在java1.0版本中,那时只是单纯地为了满足Java Applet应用而被研发出来,但如今类加载器却在OSGi,字节码加解密领域大放异彩,这主要归功于Java虚拟机的设计者们当初在设计类加载器的时候,并没有考虑将它绑定在JVM内部,这样做的好处就是能够更加灵活和动态执行类加载操作。
类加载分类
显式加载
  • 显示加载指的是在代码中通过Classloader加载class对象,如直接使用Class.forName(name)或this.getClass().getClassLoader().loadClass()加载class对象
隐式加载
  • 隐式加载则不直接在代码中调用ClassLoader的方法加载class对象,而是通过虚拟机自动加载到内存中,如在加载某个类的class文件时,该类的class文件中引用了另外一个类的对象,此时额外引用的类将通过JVM自动加载到内存中
类加载必要性
  • 避免在开发中遇到java.lang.ClassNotFoundException异常或java.lang.NoClassDefFoundError异常时,手足无措,只有了解类加载器的加载机制才能在出现异常时根据错误异常日志定位问题和解决问题
  • 需要支持类的动态加载或需要对编译后的字节码文件进行加密操作时,就需要与类加载器打交道了
  • 开发人员可以在程序中编写自定义类加载器来重新定义类的加载规则,以便实现一些自定义的处理逻辑
命名空间
何为类的唯一性
  • 对于任意一个类,都需要加载它的类加载器和这个类本身一同确认其在Java虚拟机中的唯一性,每一个类加载器,都拥有一个独立的类名称空间,**比较两个类是否相等,只有在这两个类是由同一个类加载器加载的前提下才有意义。**否则,即使这两个类源自同一个Class文件,被同一个虚拟机加载,只要加载他们的类加载器不同,那这两个类就必定不相等
命名空间
  • 每个类加载器都有自己的命名空间,命名空间由该加载器及所有的父加载器所加载的类组成
  • 在同一个命名空间中,不会出现类的完整名字相同的两个类
  • 在不同的命名空间中,有可能会出现类的完整名字相同的两个类
类加载机制的基本特征
  • 双亲委派模型:不是所有类加载都遵守这个模型,启动类加载器所加载的类型,是可能要加载用户代码的,比如JDK内部的ServiceProvider/ServiceLoader机制,用户可以在标准API框架上,提供自己的实现,JDK也需要提供些默认的参考实现,如Java中JNDI,JDBC,文件系统,Cipher等很多方面,都是利用这种机制,这种情况不会用双亲委派模型去加载,而是利用所谓的上下文加载器
  • 可见性:子类加载器可以访问父类加载器加载的类型,但是反过来是不允许的,不然,因为缺少必要的隔离,我们就没有办法利用类加载器去实现容器的逻辑
  • 单一性:由于父加载器的类型对于子加载器可见,所以父加载器中加载过的类型,就不会在子加载器中重复加载,但是注意,类加载器“邻居”间,同一类型仍然可以被加载多次,因为互相并不可见。
类加载器
  • JVM支持两种类型的类加载器,分别为引导类加载器(Bootstrap ClassLoader)和自定义类加载器(User-Defined ClassLoader)
  • 从概念上讲,自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器,但是Java虚拟机规范却没有这么定义,将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器,无论类加载器的类型如何划分,在程序中我们最常见的类加载器结构如下:
    在这里插入图片描述
  • 除了顶层的启动类加载器外,其余的类加载器都应有自己的“父类”加载器
  • 不同类加载器看似是继承(Inheritance)关系,实际上是包含关系,在下层加载器中,包含着上层加载器的引用
引导类加载器
  • 这个类加载器使用C/C++语言实现,嵌套在JVM内部
  • 它用来加载Java核心类库(JAVA_HOME/jre/lib/rt.jar或sun.boot.class.path路径下的内容)。用于提供JVM自身需要的类
  • 并不继承自java.lang.ClassLoader,没有父加载器
  • 出于安全考虑,Bootstrap启动类加载器只加载包名为java,javax,sun等开头的类
  • 加载扩展类加载器和应用程序类加载器,并指定为他们的父类加载器
  • 使用-XX:+TraceClassLoading
    在这里插入图片描述
扩展类加载器
  • Java语言编写,由sun.misc.Launcher$ExtClassLoader实现
  • 继承于ClassLoader类
  • 父类加载器为启动类加载器
  • 从java.ext.dirs系统属性所指定的目录中加载类库,或从JDK的安装目录的jre/lib/ext子目录下加载类库,如用户创建的JAR放在此目录下,也会自动由扩展类加载器加载
    在这里插入图片描述
    类加载器实验
系统类加载器(应用程序类加载器)
  • java语言编写,由sun.misc.Launcher$AppClassLoader实现
  • 派生于ClassLoader类
  • 父类加载器为扩展类加载器ExtClassLoader
  • 它负责加载环境变量classpath或系统属性java.class.path指定路径下的类库
  • 该类为程序默认的类加载器,java应用的类由它来完成加载
  • 通过ClassLoader#getSystemClassLoader()方法可以获得此类加载器
用户自定义类加载器
  • 在Java的日常应用开发中,类的加载几乎是由上述3种类加载器相互配合执行的,在必要时,我们还可以自定义类加载器,来定制类的加载方式
  • 体现Java语言的强大生命力和巨大魅力的关键因素之一便是,Java开发者可以自定义类加载器来实现类库的动态加载,加载源可以是本地的JAR包,也可以是网络上的远程资源
  • 通过类加载器可以实现非常绝妙的插件机制,这方面的实际应用安全举不胜举,例如,著名的OSGI组件框架,再如Eclipse的插件机制,类加载器为应用程序提供一种动态增加新功能的机制,这种机制无须重新打包发布应用程序就能实现
  • 同时,自定义加载器能够实现应用隔离,例如Tomcat,Spring等中间件和组件框架都在内部实现自定义的加载器,并通过自定义加载器隔离不同的组件模块,这种机制比C/C++程序要好很多,想不修改C/C++程序就能为其新增功能,几乎是不可能的,仅一个兼容性便能阻挡住所有美好设想
  • 自定义类加载器通常需要继承于ClassLoader
ClassLoader源码解析
ClassLoader与现有类加载器的关系

在这里插入图片描述

  • 除了以上虚拟机自带的加载器外,用户还可以定制自己的类加载器,Java提供了抽象类java.lang.ClassLoader,所有用户自定义的类加载器继承ClassLoader
抽象类ClassLoader主要方法
  • public final ClassLoader getParent():返回类加载器的超类加载器
  • public Class<?> loadClass(String name) throws ClassNotFoundException :加载名称为name的类,返回结果为java.lang.Class类的实例,如果找不到类,则返回ClassNotFoundException异常,该方法中的逻辑就是双亲委派模式的实现
//测试代码ClassLoader.getSystemClassLoader().loadClass("com.chapter11.User")涉及以下方法调用
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) {
                        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) {   //当前类加载器的父类加载器未加载此类或当前类加载器未加载此类
                    // 调用当前ClassLoader的findClass()
                    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;
        }
    }
  • protected Class<?> findClass(String name) throws ClassNotFoundException:查找二进制名称为name的类,返回结果为java.lang.Class类的实例,这是一个受保护的方法,JVM鼓励我们重写此方法,需要自定义加载器遵循双亲委派机制,该方法会在检查完父类加载器之后被loadClass()方法调用
  • 在JDK1.2之前,在自定义类加载时,总会去继承ClassLoader类并重写loadClass方法,从而实现自定义的类加载类,1.2后不再建议用户去覆盖loadClass()方法,而是建议把自定义的类加载逻辑写在findClass()方法中,从前面分析可知,findClass()方法是在loadClass()方法中被调用,当loadClass()方法中父加载器加载失败后,则会调用自己findClass()方法来完成类加载,这样就可以保证自定义类加载器也符合双亲委派模式
  • ClassLoader类中并没有实现findClass()方法的具体代码逻辑,取而代之的是抛出ClassNotFoundException异常,同时应该知道的是findClass方法通常和defineClass方法一起使用,一般情况下,在自定义加载器时,会直接覆盖ClassLoader的findClass()方法并编写加载规则,取得要加载类的字节码后转换成流,然后调用defineClass()方法生成类的Class对象
//在URLClassLoader中重写了findClass方法,代码如下
protected Class<?> findClass(final String name)
        throws ClassNotFoundException
    {
        final Class<?> result;
        try {
            result = AccessController.doPrivileged(
                new PrivilegedExceptionAction<Class<?>>() {
                    public Class<?> run() throws ClassNotFoundException {
                        String path = name.replace('.', '/').concat(".class");
                        Resource res = ucp.getResource(path, false);
                        if (res != null) {
                            try {
                                return defineClass(name, res);
                            } catch (IOException e) {
                                throw new ClassNotFoundException(name, e);
                            }
                        } else {
                            return null;
                        }
                    }
                }, acc);
        } catch (java.security.PrivilegedActionException pae) {
            throw (ClassNotFoundException) pae.getException();
        }
        if (result == null) {
            throw new ClassNotFoundException(name);
        }
        return result;
    }
  • protected final Class<?> defineClass(String name, byte[] b, int off, int len) throws ClassFormatError:根据给定的字节数组b转换为Class实例,off和len参数表示实际Class信息在byte数组中的位置和长度,其中byte数组b是ClassLoader从外部获取的,这是受保护的方法,只有在自定义ClassLoader子类中可以使用
  • defineClass()方法是用来将byte字节流解析成JVM能够识别的Class对象,通过这个方法不仅能够通过class文件实例化class对象,也可以通过其他方式实例化对象,如通过网络接收一个类的字节码,然后转换为byte字节流创建对应的Class对象
  • defineClass()方法通常与findClass()方法一起使用,一般情况下,在自定义类加载器时,会直接覆盖ClassLoader的findClass()方法并编写加载规则,取得要加载类的字节码转换成流,然后调用defineClass()方法生成类的Class对象
private Class<?> defineClass(String name, Resource res) throws IOException {
        long t0 = System.nanoTime();
        int i = name.lastIndexOf('.');
        URL url = res.getCodeSourceURL();
        if (i != -1) {
            String pkgname = name.substring(0, i);
            // Check if package already loaded.
            Manifest man = res.getManifest();
            definePackageInternal(pkgname, man, url);
        }
        // Now read the class bytes and define the class
        java.nio.ByteBuffer bb = res.getByteBuffer();
        if (bb != null) {
            // Use (direct) ByteBuffer:
            CodeSigner[] signers = res.getCodeSigners();
            CodeSource cs = new CodeSource(url, signers);
            sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0);
            return defineClass(name, bb, cs);
        } else {
            byte[] b = res.getBytes();
            // must read certificates AFTER reading bytes.
            CodeSigner[] signers = res.getCodeSigners();
            CodeSource cs = new CodeSource(url, signers);
            sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0);
            return defineClass(name, b, 0, b.length, cs);
        }
    }
  • protected final void resolveClass(Class<?> c) :链接指定的一个Java类,使用该方法可以使用类的Class对象创建完成的同时也被解析,前面我们说链接阶段主要是对字节码进行验证,为类变量分配内存并设置初始值同时将字节码文件中的符号引用转换为直接引用
  • protected final Class<?> findLoadedClass(String name):查找名称为name的已经被加载过的类,返回结果为java.lang.Class类的实例,这个方法是final方法,无法被修改
  • private final ClassLoader parent :它也是一个ClassLoader的实例,这个字段表示的ClassLoader也称为这个ClassLoader的双亲,在类加载过程中,ClassLoader可能会将某些请求交予自己的双亲处理
SecureClassLoader与URLClassLoader
  • SecureClassLoader扩展了ClassLoader,新增了几个与使用相关的代码源和权限定义类验证的方法,一般不直接与此类打交道,更多与其子类URLClassLoader有所关联
  • ClassLoader是一个抽象类,很多方法是空没有实现,如findClass,findResource等,而URLClassLoader这个实现类为这些方法提供了具体实现,新增了URLClassPath类协助取得Class字节码流等功能,在编写自定义类加载器时,如果没有太过于复杂的需求,可以直接继承URLClassLoader类,这样就可以避免自己去编写findClassLoader()方法及其获取字节码流的方式,使自定义类更加简洁
ExtClassLoader与AppClassLoader
  • 这两个类继承URLClassLoader,是sun.misc.Launcher的静态内部类,sun.misc.Launcher主要被系统用于启动主应用程序,ExtClassLoader和AppClassLoader都由sun.misc.Launcher创建
  • ExtClassLoader没有重写loadClass()方法,AppClassLoader重写了loadClass方法,但最终调用还是父类的loadClass()方法,因此两个类都遵循双亲委派模式
Class.forName()与ClassLoader.loadClass()
  • Class.forName()是一个静态方法,最常用的Class.forName(String className)根据传入的类的全限定名返回一个Class对象,该方法在将Class文件加载到内存的同时,会执行类的初始化
  • ClassLoader.loadClass():是一个实例方法,需要一个ClassLoader对象来调用该方法,该方法将Class文件加载到内存时,并不会执行类的初始化,直到这个类第一次使用时才进行初始化,该方法因为需要得到一个ClassLoader对象,所以可以根据需要指定使用哪个类加载器

标签:name,自定义,ClassLoader,详解,JVM,方法,Class,加载
From: https://blog.csdn.net/xuwenpeng/article/details/139355647

相关文章

  • 指针的详解延续二
     第一篇移步CSDNhttps://mp.csdn.net/mp_blog/creation/editor/139301675 第二篇移步CSDN​​​​​​​​​​​https://mp.csdn.net/mp_blog/creation/editor/139329194目录一、指针数组二、字符指针变量三、数组指针变量四、二维数组传参的本质五、函数指针变量 ......
  • C++多线程原理详解
    学习C++多线程时,我有如下疑问:mutex的lock和unlock做了什么?mutex、lock_guard、unique_lock,它们之间的关系是什么?condition_variable中的wait做了什么?带着这些疑问,我查阅了一些资料,整理出本文。文章目录一、mutex二、lock_guard三、unique_lock四、condition......
  • 【包邮送书】Node-RED 物联网应用开发技术详解
    ......
  • 关于 JVM
    内存区域划分    像办公楼一样,有办公区休息区吃饭区啥的,JVM这个应用程序就会在启动的时候就会向操作系统申请一块内存区域,然后把这个区域分成几个部分,每个部分有不同的功能作用。一个Java进程就对应一个JVM。(虽然说这里的栈也是“先进后出”的,但数据结构的栈是......
  • JSP详解,看这一篇就够了(含示例)
    JSP(JavaServerPages)是Java技术的一部分,用于创建动态Web内容。JSP的主要功能是简化服务器端的Web开发,尤其是对于HTML、XML等页面内容的动态生成。一、JSP的基础概念什么是JSP:JSP是一种基于Java的技术,用于创建动态网页。它允许在HTML中嵌入Java代码,这些代码在服务器端执......
  • 一文了解JVM面试篇(上)
     Java内存区域1、如何解释Java堆空间及GC?当通过Java命令启动Java进程的时候,会为它分配内存。内存的一部分用于创建堆空间,当程序中创建对象的时候,就从对空间中分配内存。GC是JVM内部的一个进程,回收无效对象的内存用于将来的分配。2、JVM的主要组成部分及......
  • 关于css预处理器sass详解
    Sass(SyntacticallyAwesomeStylesheets)是一种强大的CSS预处理器,旨在简化CSS的编写并增强其功能。以下是对Sass的详细解释,包括其特点、功能、语法格式以及使用方式。1.Sass的特点扩展CSS功能:Sass在CSS的基础上增加了变量、嵌套、混合(mixins)、继承等高级功能,使得CSS的编......
  • 进程间通信(27000字超详解)
    ......
  • 深入解析力扣170题:两数之和 III - 数据结构设计(哈希表与双指针法详解及模拟面试问答)
    在本篇文章中,我们将详细解读力扣第170题“两数之和III-数据结构设计”。通过学习本篇文章,读者将掌握如何设计一个数据结构来支持两种操作,并了解相关的复杂度分析和模拟面试问答。每种方法都将配以详细的解释和ASCII图解,以便于理解。问题描述力扣第170题“两数之和III......
  • TorchServe详解和应用
    TorchServer是PyTorch的一个组件,它是一个轻量级的服务框架,用于部署和管理PyTorch模型,以便在生产环境中提供高效、可扩展的推理服务。TorchServer提供了RESTfulAPI,可以方便地与其他系统集成,支持模型热加载和热更新,确保模型的快速部署和更新。以下是TorchServer的一些关键特......