Android插件化开发基础之Java类加载器与双亲委派模型

举报
chenyu 发表于 2021/07/26 23:25:42 2021/07/26
【摘要】 类加载器 Java虚拟机类加载过程是把Class类文件加载到内存，并对Class文件中的数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的java类型的过程。 在加载阶段，java虚拟机需要完成以下3件事： a.通过一个类的全限定名来获取定义此类的二进制字节流。 b.将定义类的二进制字节流所代表的静态存储结构转换为方法区的运...

类加载器

Java虚拟机类加载过程是把Class类文件加载到内存，并对Class文件中的数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的java类型的过程。

在加载阶段，java虚拟机需要完成以下3件事：

a.通过一个类的全限定名来获取定义此类的二进制字节流。

b.将定义类的二进制字节流所代表的静态存储结构转换为方法区的运行时数据结构。

c.在java堆中生成一个代表该类的java.lang.Class对象，作为方法区数据的访问入口。

而类的加载过程是通过类加载器完成的。


在Java中，任意一个类都需要由加载它的类加载器和这个类本身一同确定其在java虚拟机中的唯一性，即比较两个类是否相等，只有在这两个类是由同一个类加载器加载的前提之下才有意义，否则，即使这两个类来源于同一个Class类文件，只要加载它的类加载器不相同，那么这两个类必定不相等(这里的相等包括代表类的Class对象的equals()方法、isAssignableFrom()方法、isInstance()方法和instanceof关键字的结果)。


加载类的开放性

类加载器（ClassLoader）是Java语言的一项创新，也是Java流行的一个重要原因。在类加载的第一阶段“加载”过程中，需要通过一个类的全限定名来获取定义此类的二进制字节流，完成这个动作的代码块就是类加载器。这一动作是放在Java虚拟机外部去实现的，以便让应用程序自己决定如何获取所需的类。

虚拟机规范并没有指明二进制字节流要从一个Class文件获取，或者说根本没有指明从哪里获取、怎样获取。这种开放使得Java在很多领域得到充分运用，例如：

  • 从ZIP包中读取，这很常见，成为JAR，EAR，WAR格式的基础
  • 从网络中获取，最典型的应用就是Applet
  • 运行时计算生成，最典型的是动态代理技术，在java.lang.reflect.Proxy中，就是用了ProxyGenerator.generateProxyClass来为特定接口生成形式为“*$Proxy”的代理类的二进制字节流
  • 有其他文件生成，最典型的JSP应用，由JSP文件生成对应的Class类 
    ……

类加载器与类的唯一性

类加载器虽然只用于实现类的加载动作，但是对于任意一个类，都需要由加载它的类加载器和这个类本身共同确立其在Java虚拟机中的唯一性。通俗的说，JVM中两个类是否“相等”，首先就必须是同一个类加载器加载的，否则，即使这两个类来源于同一个Class文件，被同一个虚拟机加载，只要类加载器不同，那么这两个类必定是不相等的。

这里的“相等”，包括代表类的Class对象的equals()方法、isAssignableFrom()方法、isInstance()方法的返回结果，也包括使用instanceof关键字做对象所属关系判定等情况。

以下代码说明了不同的类加载器对instanceof关键字运算的结果的影响。


  
    
   
  1. 
    
    
     
    
    
    
    
    
     
    
      package com.jvm.classloading;
     
    
    
    2. 
   
  2. 
    
    
     
    
    
    
    
    
     
     
     
    
    
    3. 
   
  3. 
    
    
     
    
    
    
    
    
     
    
      import java.io.IOException;
     
    
    
    4. 
   
  4. 
    
    
     
    
    
    
    
    
     
    
      import java.io.InputStream;
     
    
    
    5. 
   
  5. 
    
    
     
    
    
    
    
    
     
     
     
    
    
    6. 
   
  6. 
    
    
     
    
    
    
    
    
     
    
      /**
     
    
    
    7. 
   
  7. 
    
    
     
    
    
    
    
    
     
    
       * 类加载器在类相等判断中的影响
     
    
    
    8. 
   
  8. 
    
    
     
    
    
    
    
    
     
    
       * 
     
    
    
    9. 
   
  9. 
    
    
     
    
    
    
    
    
     
    
       * instanceof关键字
     
    
    
    10. 
   
  10. 
    
    
     
    
    
    
    
    
     
    
       * 
     
    
    
    11. 
   
  11. 
    
    
     
    
    
    
    
    
     
    
       */
     
    
    
    12. 
   
  12. 
    
    
     
    
    
    
    
    
     
     
     
    
    
    13. 
   
  13. 
    
    
     
    
    
    
    
    
     
    
      public class ClassLoaderTest {
     
    
    
    14. 
   
  14. 
    
    
     
    
    
    
    
    
     
     public static void main(String[] args) throws Exception {
     
    
    
    15. 
   
  15. 
    
    
     
    
    
    
    
    
     
     // 自定义类加载器
     
    
    
    16. 
   
  16. 
    
    
     
    
    
    
    
    
     
    
       ClassLoader myLoader = new ClassLoader() {
     
    
    
    17. 
   
  17. 
    
    
     
    
    
    
    
    
     
     @Override
     
    
    
    18. 
   
  18. 
    
    
     
    
    
    
    
    
     
     public Class<?> loadClass(String name) throws ClassNotFoundException {
     
    
    
    19. 
   
  19. 
    
    
     
    
    
    
    
    
     
     try {
     
    
    
    20. 
   
  20. 
    
    
     
    
    
    
    
    
     
    
       String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
     
    
    
    21. 
   
  21. 
    
    
     
    
    
    
    
    
     
    
       InputStream is = getClass().getResourceAsStream(fileName);
     
    
    
    22. 
   
  22. 
    
    
     
    
    
    
    
    
     
     if (is == null) {
     
    
    
    23. 
   
  23. 
    
    
     
    
    
    
    
    
     
     return super.loadClass(fileName);
     
    
    
    24. 
   
  24. 
    
    
     
    
    
    
    
    
     
    
       }
     
    
    
    25. 
   
  25. 
    
    
     
    
    
    
    
    
     
     byte[] b = new byte[is.available()];
     
    
    
    26. 
   
  26. 
    
    
     
    
    
    
    
    
     
    
       is.read(b);
     
    
    
    27. 
   
  27. 
    
    
     
    
    
    
    
    
     
     return defineClass(name, b, 0, b.length);   
     
    
    
    28. 
   
  28. 
    
    
     
    
    
    
    
    
     
    
       } catch (IOException e) {
     
    
    
    29. 
   
  29. 
    
    
     
    
    
    
    
    
     
     throw new ClassNotFoundException();
     
    
    
    30. 
   
  30. 
    
    
     
    
    
    
    
    
     
    
       }
     
    
    
    31. 
   
  31. 
    
    
     
    
    
    
    
    
     
    
       }
     
    
    
    32. 
   
  32. 
    
    
     
    
    
    
    
    
     
    
       };
     
    
    
    33. 
   
  33. 
    
    
     
    
    
    
    
    
     
     
     
    
    
    34. 
   
  34. 
    
    
     
    
    
    
    
    
     
     // 使用ClassLoaderTest的类加载器加载本类
     
    
    
    35. 
   
  35. 
    
    
     
    
    
    
    
    
     
    
       Object obj1 = ClassLoaderTest.class.getClassLoader().loadClass("com.jvm.classloading.ClassLoaderTest").newInstance();
     
    
    
    36. 
   
  36. 
    
    
     
    
    
    
    
    
     
    
       System.out.println(obj1.getClass());
     
    
    
    37. 
   
  37. 
    
    
     
    
    
    
    
    
     
    
       System.out.println(obj1 instanceof com.jvm.classloading.ClassLoaderTest);
     
    
    
    38. 
   
  38. 
    
    
     
    
    
    
    
    
     
     
     
    
    
    39. 
   
  39. 
    
    
     
    
    
    
    
    
     
     // 使用自定义类加载器加载本类
     
    
    
    40. 
   
  40. 
    
    
     
    
    
    
    
    
     
    
       Object obj2 = myLoader.loadClass("com.jvm.classloading.ClassLoaderTest").newInstance();
     
    
    
    41. 
   
  41. 
    
    
     
    
    
    
    
    
     
    
       System.out.println(obj2.getClass());
     
    
    
    42. 
   
  42. 
    
    
     
    
    
    
    
    
     
    
       System.out.println(obj2 instanceof com.jvm.classloading.ClassLoaderTest);
     
    
    
    43. 
   
  43. 
    
    
     
    
    
    
    
    
     
    
       }
     
    
    
    44. 
   
  44. 
    
    
     
    
    
    
    
    
     
    
      }
     
    
    
    45. 
  

 
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    • 
  
  • 21
    • 
  
  • 22
    • 
  
  • 23
    • 
  
  • 24
    • 
  
  • 25
    • 
  
  • 26
    • 
  
  • 27
    • 
  
  • 28
    • 
  
  • 29
    • 
  
  • 30
    • 
  
  • 31
    • 
  
  • 32
    • 
  
  • 33
    • 
  
  • 34
    • 
  
  • 35
    • 
  
  • 36
    • 
  
  • 37
    • 
  
  • 38
    • 
  
  • 39
    • 
  
  • 40
    • 
  
  • 41
    • 
  
  • 42
    • 
  
  • 43
    • 
  
  • 44
    • 
  
  • 45
    • 
 

 
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    • 
  
  • 21
    • 
  
  • 22
    • 
  
  • 23
    • 
  
  • 24
    • 
  
  • 25
    • 
  
  • 26
    • 
  
  • 27
    • 
  
  • 28
    • 
  
  • 29
    • 
  
  • 30
    • 
  
  • 31
    • 
  
  • 32
    • 
  
  • 33
    • 
  
  • 34
    • 
  
  • 35
    • 
  
  • 36
    • 
  
  • 37
    • 
  
  • 38
    • 
  
  • 39
    • 
  
  • 40
    • 
  
  • 41
    • 
  
  • 42
    • 
  
  • 43
    • 
  
  • 44
    • 
  
  • 45
    •

输出结果：


  
    
   
  1. 
    
    
     
    
    
    
    
    
     
    
      class com.jvm.classloading.ClassLoaderTest
     
    
    
    2. 
   
  2. 
    
    
     
    
    
    
    
    
     
    
      true
     
    
    
    3. 
   
  3. 
    
    
     
    
    
    
    
    
     
    
      class com.jvm.classloading.ClassLoaderTest
     
    
    
    4. 
   
  4. 
    
    
     
    
    
    
    
    
     
    
      false
     
    
    
    5. 
  

 
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
 

 
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    •

myLoader是自定义的类加载器，可以用来加载与自己在同一路径下的Class文件。main函数的第一部分使用系统加载主类ClassLoaderTest的类加载器加载ClassLoaderTest，输出显示，obj1的所属类型检查正确，这是虚拟机中有2个ClassLoaderTest类，一个是主类，另一个是main()方法中加载的类，由于这两个类使用同一个类加载器加载并且来源于同一个Class文件，因此这两个类是完全相同的。

第二部分使用自定义的类加载器加载ClassLoaderTest，class com.jvm.classloading.ClassLoderTest显示，obj2确实是类com.jvm.classloading.ClassLoaderTest实例化出来的对象，但是第二句输出false。此时虚拟机中有3个ClassLoaderTest类，由于第3个类的类加载器与前面2个类加载器不同，虽然来源于同一个Class文件，但它是一个独立的类，所属类型检查是返回结果自然是false。

双亲委派模型

类加载器种类

从Java虚拟机的角度来说，只存在两种不同的类加载器：一种是启动类加载器（Bootstrap ClassLoader），这个类加载器使用C++语言实现（HotSpot虚拟机中），是虚拟机自身的一部分；另一种就是所有其他的类加载器，这些类加载器都有Java语言实现，独立于虚拟机外部，并且全部继承自java.lang.ClassLoader。

从开发者的角度，类加载器可以细分为：

  • 启动（Bootstrap）类加载器：负责将 Java_Home/lib下面的类库加载到内存中（比如rt.jar）。由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不允许直接通过引用进行操作。

  • 标准扩展（Extension）类加载器：是由 Sun 的 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将Java_Home /lib/ext或者由系统变量 java.ext.dir指定位置中的类库加载到内存中。开发者可以直接使用标准扩展类加载器。

  • 应用程序（Application）类加载器：是由 Sun 的 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。它负责将系统类路径（CLASSPATH）中指定的类库加载到内存中。开发者可以直接使用系统类加载器。由于这个类加载器是ClassLoader中的getSystemClassLoader()方法的返回值，因此一般称为系统（System）加载器。

除此之外，还有自定义的类加载器，它们之间的层次关系被称为类加载器的双亲委派模型。该模型要求除了顶层的启动类加载器外，其余的类加载器都应该有自己的父类加载器，而这种父子关系一般通过组合（Composition）关系来实现，而不是通过继承（Inheritance）。

类加载器的双亲委派模型

双亲委派模型

双亲委派模型过程

某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。

使用双亲委派模型的好处在于Java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类java.lang.Object，它存在在rt.jar中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的Bootstrap ClassLoader进行加载，因此Object类在程序的各种类加载器环境中都是同一个类。相反，如果没有双亲委派模型而是由各个类加载器自行加载的话，如果用户编写了一个java.lang.Object的同名类并放在ClassPath中，那系统中将会出现多个不同的Object类，程序将混乱。因此，如果开发者尝试编写一个与rt.jar类库中重名的Java类，可以正常编译，但是永远无法被加载运行。

双亲委派模型的系统实现

在java.lang.ClassLoader的loadClass()方法中，先检查是否已经被加载过，若没有加载则调用父类加载器的loadClass()方法，若父加载器为空则默认使用启动类加载器作为父加载器。如果父加载失败，则抛出ClassNotFoundException异常后，再调用自己的findClass()方法进行加载。


  
    
   
  1. 
    
    
     
    
    
    
    
    
     
    
      protected synchronized Class<?> loadClass(String name,boolean resolve)throws ClassNotFoundException{
     
    
    
    2. 
   
  2. 
    
    
     
    
    
    
    
    
     
     //check the class has been loaded or not
     
    
    
    3. 
   
  3. 
    
    
     
    
    
    
    
    
     
    
       Class c = findLoadedClass(name);
     
    
    
    4. 
   
  4. 
    
    
     
    
    
    
    
    
     
     if(c == null){
     
    
    
    5. 
   
  5. 
    
    
     
    
    
    
    
    
     
     try{
     
    
    
    6. 
   
  6. 
    
    
     
    
    
    
    
    
     
     if(parent != null){
     
    
    
    7. 
   
  7. 
    
    
     
    
    
    
    
    
     
    
       c = parent.loadClass(name,false);
     
    
    
    8. 
   
  8. 
    
    
     
    
    
    
    
    
     
    
       }else{
     
    
    
    9. 
   
  9. 
    
    
     
    
    
    
    
    
     
    
       c = findBootstrapClassOrNull(name);
     
    
    
    10. 
   
  10. 
    
    
     
    
    
    
    
    
     
    
       }
     
    
    
    11. 
   
  11. 
    
    
     
    
    
    
    
    
     
    
       }catch(ClassNotFoundException e){
     
    
    
    12. 
   
  12. 
    
    
     
    
    
    
    
    
     
     //if throws the exception ,the father can not complete the load
     
    
    
    13. 
   
  13. 
    
    
     
    
    
    
    
    
     
    
       }
     
    
    
    14. 
   
  14. 
    
    
     
    
    
    
    
    
     
     if(c == null){
     
    
    
    15. 
   
  15. 
    
    
     
    
    
    
    
    
     
    
       c = findClass(name);
     
    
    
    16. 
   
  16. 
    
    
     
    
    
    
    
    
     
    
       }
     
    
    
    17. 
   
  17. 
    
    
     
    
    
    
    
    
     
    
       }
     
    
    
    18. 
   
  18. 
    
    
     
    
    
    
    
    
     
     if(resolve){
     
    
    
    19. 
   
  19. 
    
    
     
    
    
    
    
    
     
    
       resolveClass(c);
     
    
    
    20. 
   
  20. 
    
    
     
    
    
    
    
    
     
    
       }
     
    
    
    21. 
   
  21. 
    
    
     
    
    
    
    
    
     
     return c;
     
    
    
    22. 
   
  22. 
    
    
     
    
    
    
    
    
     
    
      }
     
    
    
    23. 
  

 
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    • 
  
  • 21
    • 
  
  • 22
    • 
 

 
 

  
 
 

 
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    • 
  
  • 21
    • 
  
  • 22
    •

注意，双亲委派模型是Java设计者推荐给开发者的类加载器的实现方式，并不是强制规定的。大多数的类加载器都遵循这个模型，但是JDK中也有较大规模破坏双亲模型的情况，例如线程上下文类加载器（Thread Context ClassLoader）的出现，具体分析可以参见周志明著《深入理解Java虚拟机》。

参考 
1、周志明，深入理解Java虚拟机：JVM高级特性与最佳实践，机械工业出版社 
2、Alexia(minmin)博客，http://www.cnblogs.com/lanxuezaipiao/p/4138511.html


文章来源: chenyu.blog.csdn.net，作者：chen.yu，版权归原作者所有，如需转载，请联系作者。

原文链接：chenyu.blog.csdn.net/article/details/53248345

【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Android Java
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入