类加载器分类

Class 的加载阶段由类加载器 ClassLoader 及其子类负责。ClassLoader 是一个重要的 Java 运行时系统组件，它负责在运行时查找和装入 Class 字节码文件。JVM 在运行时会产生三个ClassLoader：BootstrapClassLoader（根装载器）、ExtClassLoader（扩展类装载器）和AppClassLoader（系统类装载器）。

  • 根装载器（BootstrapClassLoader：启动类加载器，是JVM内置的加载器）
    • 用来加载%JAVA_HOME%/jre/lib路径下的类；
    • 可以使用 -Xbootclasspath 参数来指定加载路径；
    • 由C++实现，无法通过 ExtClassLoader.getParent() 方法获得；
    • sun.misc.Launcher.getBootstrapClassPath()方法可以获得启动类加载器目录；
  • ExtClassLoader和AppClassLoader都是ClassLoader的子类：
    • ExtClassLoader ：扩展类加载器，负责装载 JRE扩展目录（%JAVA_HOME%/lib/ext 或者由 java.ext.dirs 系统属性指定的目录中的JAR包的类），父类加载器为 null
    • AppClassLoader：应用程序类加载器，它负责在 JVM 启动时加载来自Java命令的 -classpath 选项、 java.class.path 系统属性，或者 CLASSPATH 换将变量所指定的JAR包和类路径。程序可以通过 ClassLoader 的静态方法 getSystemClassLoader() 来获取系统类加载器。如果没有特别指定，则用户自定义的类加载器都以此类加载器作为父加载器。由Java语言实现，父类加载器为 ExtClassLoader

注意事项：

  • 这三个类装载器之间存在父子层级关系，即根装载器是 ExtClassLoader 的父装载器，ExtClassLoader 是 AppClassLoader 的父装载器
  • 默认情况下，使用 AppClassLoader 装载应用程序的类
  • ThreadContextClassLoader：线程上下文加载器，可以是以上任意一种类加载器 ```java import java.net.URL;

public class ClassloaderTest { public static void main(String[] args) { // 获取启动类加载器的加载路径 for(URL item:sun.misc.Launcher. getBootstrapClassPath().getURLs()){ System.out.println(item); } // 获取当前线程的加载器 ClassLoader loader=Thread.currentThread().getContextClassLoader(); System.out.println(loader); System.out.println(loader.getParent()); System.out.println(loader.getParent().getParent()); } } // 输出： file:/D:/exefile/Java/jre/lib/resources.jar file:/D:/exefile/Java/jre/lib/rt.jar file:/D:/exefile/Java/jre/lib/sunrsasign.jar file:/D:/exefile/Java/jre/lib/jsse.jar file:/D:/exefile/Java/jre/lib/jce.jar file:/D:/exefile/Java/jre/lib/charsets.jar file:/D:/exefile/Java/jre/lib/jfr.jar file:/D:/exefile/Java/jre/classes sun.misc.Launcher$AppClassLoader@18b4aac2 sun.misc.Launcher$ExtClassLoader@1b6d3586 null

  2. <a name="mJhew"></a>
  3. #### 类加载器工作模式
  5. 1. 检测此 Class 是否载入过，即在缓冲区中是否有此 Class，如果有直接进入第8步，否则进入第2步；
  6. 1. 如果没有父类加载器，则要么 Parent 是根类加载器，要么本身就是根类加载器，则跳到第4步，如果父类加载器存在，则进入第3步；
  7. 1. 请求使用父类加载器去载入目标类，如果载入成功则跳至第8步，否则接着执行第5步；
  8. 1. 请求使用根类加载器去载入目标类，如果载入成功则跳至第8步，否则跳至第7步；
  9. 1. 当前类加载器尝试寻找 Class 文件，如果找到则执行第6步，如果找不到则执行第7步；
  10. 1. 从文件中载入Class，成功后跳至第8步；
  11. 1. 抛出 ClassNotFountException 异常；
  12. 1. 返回对应的 java.lang.Class 对象；
  14. <a name="bqWC4"></a>
  15. #### 类加载时间
  17. 常见情况：
  19. 1. 创建类的实例，也就是new一个对象
  20. 1. 访问某个类或接口的静态变量，或者对该静态变量赋值
  21. 1. 调用类的静态方法
  22. 1. 反射（Class.forName("com.lyj.load")）
  23. 1. 初始化一个类的子类（会首先初始化子类的父类）
  24. 1. JVM启动时标明的启动类，即文件名和类名相同的那个类
  26. 特殊情况：对于一个final类型的静态变量
  28. - 如果该变量的值在编译时就可以确定下来，那么这个变量相当于“宏变量”。Java编译器会在编译时直接把这个变量出现的地方替换成它的值，因此即使程序使用该静态变量，也不会导致该类的初始化。
  29. - 反之，如果final类型的静态Field的值不能在编译时确定下来，则必须等到运行时才可以确定该变量的值，如果通过该类来访问它的静态变量，则会导致该类被初始化。
  31. <a name="0V396"></a>
  32. #### 类加载机制
  34. JVM 加载类时使用“全盘负责委托机制”：
  36. - “全盘负责”：是指当一个 ClassLoader 装载一个类的时，除非显式地使用另一个ClassLoader 来加载，否则该类所依赖及引用的类也由这个 ClassLoader 载入；
  37. - “委托机制”：**是指先委托父装载器寻找目标类，只有在找不到的情况下才从自己的类路径中查找并装载目标类。**这一点是从安全角度考虑的，试想如果有人编写了一个恶意的基础类（如java.lang.String）并装载到JVM中将会引起多么可怕的后果。但是由于有了“全盘负责委托机制”，java.lang.String 永远是由根装载器来装载的，这样就避免了上述事件的发生
  38. - “缓存机制”：缓存机制将会保证所有加载过的 Class 都会被缓存，当程序中需要使用某个 Class 时，类加载器先从缓存区中搜寻该 Class，只有当缓存区中不存在该 Class 对象时，系统才会读取该类对应的二进制数据，并将其转换成 Class 对象，存入缓冲区中。**这就是为什么修改了 Class 后，必须重新启动JVM，程序所做的修改才会生效的原因**
  40. **<br />双亲委派机制：
  42. 1. 加载顺序：用户类加载器--->系统类加载器--->扩展类加载器--->根类加载器
  43. 1. 原理：如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器。如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式
  44. 1. 优势：
  45.    - 避免重复加载：Java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关可以避免类的重复加载，当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次
  46.    - 安全性：java 核心 api 中定义类型不会被随意替换，假设通过网络传递一个名为java.lang.Integer 的类，通过双亲委托模式传递到启动类加载器，而启动类加载器在核心Java API 发现这个名字的类，发现该类已被加载，并不会重新加载网络传递的过来的java.lang.Integer，而直接返回已加载过的 Integer.class，这样便可以防止核心API库被随意篡改
  48. <br />
  49. <a name="btJJV"></a>
  50. #### 自定义 ClassLoader
  52. 在Java中，ClassLoader是一个抽象类，位于java.lang包中，常用方法如下：
  54. - `Class loadClass(String name)` ：name参数指定类装载器需要装载类的名字，必须使用全限定类名，如 com.example.Car。该方法有一个重载方法`loadClass(String name ,boolean resolve)`，resolve参数告诉类装载器是否需要解析该类。在初始化类之前，应考虑进行类解析的工作，但并不是所有的类都需要解析，如果JVM只需要知道该类是否存在或找出该类的超类，那么就不需要进行解析；
  55. - `Class defineClass(String name, byte[] b, int off, int len)`： 将类文件的字节数组转换成JVM内部的java.lang.Class对象。字节数组可以从本地文件系统、远程网络获取。name为字节数组对应的全限定类名；
  56. - `Class findSystemClass(String name)`： 从本地文件系统载入Class文件，如果本地文件系统不存在该Class文件，将抛出 ClassNotFoundException 异常。该方法是JVM默认使用的装载机制；
  57. - `Class findLoadedClass(String name)` ：调用该方法来查看ClassLoader是否已装入某个类。如果已装入，那么返回 java.lang.Class 对象，否则返回null。如果强行装载已存在的类，将会抛出链接错误；
  58. - `ClassLoader getParent()`： 获取类装载器的父装载器，除根装载器外，所有的类装载器都有且仅有一个父装载器，ExtClassLoader的父装载器是根装载器，因为根装载器非Java编写，所以无法获得，将返回null；
  60. 获取类加载器：
  62. 1. java.lang.Class
  63.    - ClassLoader getClassLoader(): 获取加载该类的类加载器
  64. 2. java.lang.ClassLoader
  65.    - ClassLoader  getParent()：返回父类加载器，如果父类加载器是引导类加载器，则返回null。<br />
  66.    - static ClassLoader getSystemClassLoader()：获取系统类加载器，即用于加载第一个应用类的类加载器。<br />
  67.    - protected Class findClass(String name)：类加载器应该覆盖该方法，以查找类的字节码，并通过调用defineClass方法将字节码传给虚拟机。在类的名字中，使用.作为包名分隔符，并且不使用.class后缀。<br />
  68.    - Class definedClass(String name, byte[] byteCodeData, int offset, int length)：将一个新的类添加到虚拟机，其字节码在给定的数据范围中。<br />
  69. 3. java.net.URLClassLoader
  70.    - URLClassLoader(URL[] urls)
  71.    - URLClassLoader(URL[] urls, ClassLoader parent) ：构建一个类加载器，它可以从给定的URL处加载类。如果URL以 / 结尾，那么它表示的一个目录，否则，它表示的是一个JAR文件。
  72. 4. java.lang.Thread
  73.    - ClassLoader getContextClassLoader()：获取类加载器，该线程的创建者将其指定为执行该线程时最适合使用的类加载器。<br />
  74.    - void setContextClassLoader(ClassLoader loader)：为该线程中的代码设置一个类加载器，以获取要加载的类。如果在启动一个线程时没有显式地设置上下文类加载器，则使用父线程的上下文类加载器。<br />
  76. 自定义 ClassLoader ：
  78. 1. 继承抽象类 ClassLoader
  79. 1. 实现类加载方法：根据需求进行重写
  80.    - Class<?> findClass(String name)：不需要打破双亲委派模型，则重写此方法
  81.    - Class<?> loadClass(String name, boolean resolve)：需要打破双亲委派模型，则可以重写此方法
  82. 3. 如果需要从其他地方加载类，则需要使用 defineClass 方法，将二进制字节流文件转换成一个 java.lang.Class
  83. 3. 使用 Class.forName 的重载方法，使用自定义的类加载器加载类
  84. > 不直接继承 AppClassLoader 的原因：AppClassLoader和ExtClassLoader加载器都是Launcher的静态类，都是包访问路径权限的(private修饰)。
  86. ```java
  87. /* 自定义类加载器，从 D 盘加载文件 */
  88. public class MyClassLoader extends ClassLoader {
  89.     // 重写 findClass 方法
  90.     @Override
  91.     protected Class<?> findClass(String name) throws ClassNotFoundException {
  92.         byte[] bytes = getClassBytes(name);
  93.         // 使用 defineClass 将加载进来的二进制转换成 Class
  94.         return super.defineClass(name, bytes, 0, bytes.length);
  95.     }
  97.     private byte[] getClassBytes(String name) {
  98.         File file = new File(classNameToPath(name));
  99.         // 获取文件的大小，字节数
  100.         long len = file.length();
  101.         byte[] res = new byte[(int) len];
  102.         try (FileInputStream fis = new FileInputStream(file)) {
  103.             int read = fis.read(res);
  104.             if (len != read) {
  105.                 throw new IOException("无法读取全部文件：" + read + "!=" + len);
  106.             }
  107.         } catch (IOException e) {
  108.             e.printStackTrace();
  109.         }
  110.         return res;
  111.     }
  113.     private String classNameToPath(String className) {
  114.         // 将 .class 文件放在 D 盘
  115.         return "D:" + File.separator
  116.             + className.substring(className.lastIndexOf(".") + 1)
  117.             + ".class";
  118.     }
  119. }
  121. /* 测试 */
  122. public static void main(String[] args) throws Exception{
  123.     MyClassLoader loader = new MyClassLoader();
  124.     // 使用 Class.forName 通过自定义的类加载器加载类 
  125.     Class<?> clazz = Class.forName("top.songfang.reflect.loader.User", true, loader);
  126.     // 创建对象：这里不能强转，因为强转会隐性加载User类
  127.     Object obj = clazz.getDeclaredConstructor().newInstance();
  128.     // 输出类加载器
  129.     System.out.println(obj.getClass().getClassLoader());
  130.     // 调用方法
  131.     Method print = clazz.getMethod("print");
  132.     print.invoke(obj);
  133. }

注意事项：

  1. 在通过 idea 的环境时，由于 idea 会自动编译，因此需要将需要加载的类删掉，同时将其编译的 class 文件删掉，否则不会使用自定义的类加载器加载文件；或者覆写构造方法，传入父加载器
  2. 从网络上加载 class 文件：
    1. URL url = new URL("");
    2. InputStream input = url.openStream();
    3. ByteArrayOutputStream bos = new ByteArrayOutputStream();
    4. byte[] data = new byte[1024];
    5. int len = 0;
    6. while((len = input.read(data) != -1){
    7.  bos.write(data,0,len);
    8. }
    9. byte[] classByte = bos.toByteArray();