类加载器的分类

JVM支持两种类型的类加载器,分别为引导类加载器(BootstrapClassLoader)和自定义类加载器(User-Defined ClassLoader)

从概念上来讲, 自定义类加载器一般指的是程序中由开发人员自定义的一类,类加载器,但是Java虚拟机规范却没有这么定义,而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器

无论类加载器的类型如何划分,在程序中我们最常见的类加载器始终只有3个,如下所示:

所以具体为引导类加载器(BootstrapClassLoader)和自定义类加载器（包括ExtensionClassLoader、Application ClassLoader、User Defined ClassLoader）

Application ClassLoader也叫System ClassLoader

可以看出ExtensionClassLoader、APPClassLoader都间接继承了ClassLoader。

四类加载器之间的关系可以看做是阶级关系，分为上下级，并不是子父类的继承关系。

Boot strapClassLoader由C/C++实现的，其他三类加载器是由Java实现的

package com.dongguo.jvm02;/*** @author Dongguo* @date 2021/8/26 0026-9:07* @description:*/
public class ClassLoader1 {public static void main(String[] args) {//获取系统类加载器ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2//获取上层 扩展类加载器ClassLoader extClassLoader = systemClassLoader.getParent();System.out.println(extClassLoader);//sun.misc.Launcher$ExtClassLoader@1b6d3586//获取上层 引用类加载器  获取不到引用类加载器ClassLoader bootStrapClassLoader = extClassLoader.getParent();System.out.println(bootStrapClassLoader);//null//对于用户自定义类使用的加载器  默认使用系统类加载器加载ClassLoader classLoader = ClassLoader1.class.getClassLoader();System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2//String类使用引导类加载器加载，Java核心类库都是使用引导类加载器加载ClassLoader StringClassLoader = String.class.getClassLoader();System.out.println(StringClassLoader);//null}
}

虚拟机自带的加载器

启动类加载器（引导类加载器 BootStrap ClassLoader）

这个类加载使用C/C++语言实现的,嵌套在JVM内部。

它用来加载Java的核心库(JAVA HOME/jre/lib/rt.jar.resources.jar或sun.boot.class. path路径下的内容) ,用于提供JVM自身需要的类

并不继承自java.lang.ClassLoader,没有父加载器。

加载扩展类和应用程序类加载器,并指定为他们的父类加载器。

出于安全考虑, Bootstrap启动类加载器只加载包名为java, javax.sun等开头的类

扩展类加载器（Extension ClassLoader）

Java语言编写,由sun.misc. Launcher$ExtclassLoader实现

派生于ClassLoader类

父类加载器为启动类加载器

从java.ext.dirs系统属性所指定的目录中加载类库,或从JDK的安装目录的jre/lib/ext子目录(扩展目录)下加载类库。如果用户创建的JAR放在此目录下,也会自动由扩展类加载器加载。

应用类加载器（系统类加载器 AppClassLoader）

java语言编写,由sun.misc.Launcher$AppClassLoader实现

派生于classLoader类

父类加载器为扩展类加载器

它负责加载环境变量classpath或系统属性java.class.path指定路径下的类库

该类加载是程序中默认的类加载器,一般来说, Java应用的类都是由它来完成加载

通过ClassLoader#getSystemClassLoader()方法可以获取到该类加载器

package com.dongguo.jvm02;import com.sun.net.ssl.internal.ssl.Provider;
import sun.misc.Launcher;import java.net.URL;/*** @author Dongguo* @date 2021/8/26 0026-9:27* @description:*/
public class ClassLoader2 {public static void main(String[] args) {System.out.println("------启动类加载器------");//获取BootStrapClassLoader能够加载的API的路径URL[] urLs = Launcher.getBootstrapClassPath().getURLs();for (URL url : urLs) {System.out.println(url.toExternalForm());}/*------启动类加载器------file:/E:/software/java/jdk/jre/lib/resources.jarfile:/E:/software/java/jdk/jre/lib/rt.jarfile:/E:/software/java/jdk/jre/lib/sunrsasign.jarfile:/E:/software/java/jdk/jre/lib/jsse.jarfile:/E:/software/java/jdk/jre/lib/jce.jarfile:/E:/software/java/jdk/jre/lib/charsets.jarfile:/E:/software/java/jdk/jre/lib/jfr.jarfile:/E:/software/java/jdk/jre/classes*///从上面的路径中随意选择一个类，查看使用的类加载器ClassLoader classLoader = Provider.class.getClassLoader();System.out.println(classLoader);//null    //说明使用的是BootStrapClassLoader加载}
}

package com.dongguo.jvm02;import sun.misc.Launcher;
import sun.security.ec.ECKeyFactory;import java.net.URL;
import java.security.interfaces.ECKey;
import java.util.Properties;/*** @author Dongguo* @date 2021/8/26 0026-9:47* @description:*/
public class ClassLoader3 {public static void main(String[] args) {System.out.println("------扩展类加载器------");//获取SystemClassLoader能够加载的API的路径String extDirs = System.getProperty("java.ext.dirs");for (String path : extDirs.split(";")) {System.out.println(path);}/*------扩展类加载器------E:\software\java\jdk\jre\lib\extC:\WINDOWS\Sun\Java\lib\ext*///从上面的路径中随意选择一个类，查看使用的类加载器ClassLoader classLoader = ECKeyFactory.class.getClassLoader();System.out.println(classLoader);//sun.misc.Launcher$ExtClassLoader@1b6d3586 //扩展类加载器}
}

用户自定义的加载器

用户自定义类加载器

在Java的日常应用程序开发中,类的加载几乎是由上述3种类加载器相互配合执行的,在必要时,我们还可以自定义类加载器,来定制类的加载方式

为什么要自定义类加载器?

隔离加载类

修改类加载的方式

扩展加载源

防止源码泄漏

用户自定义类加载器实现步骤:

1,开发人员可以通过继承抽象类java . lang.ClassLoader类的方式,实现自己的类加载器,以满足一些特殊的需求

2,在JDK1.2之前,在自定义类加载器时,总会去继承ClassLoader类并重写loadClass ()方法,从而实现自定义的类加载类,但是在JDK1.2之后已不再建议用户去覆盖loadClass ()方法,而是建议把自定义的类加载逻辑写在findClass ()方法中

3·在编写自定义类加载器时,如果没有太过于复杂的需求,可以直接继承URLCIassLoader类,这样就可以避免自己去编写findclass ()方法及其获取字节码流的方式,使自定义类加载器编写更加简洁。

自定义用户类加载器大致流程

package com.dongguo.jvm02;import java.io.FileNotFoundException;/*** @author Dongguo* @date 2021/8/26 0026-10:01* @description: 自定义用户类加载器大致流程*/
public class CustomClassLoader extends ClassLoader {@Overrideprotected Class<?> findClass(String name) throws ClassNotFoundException {try {byte[] result = getClassFromCustomPath(name);if (result == null) {throw new FileNotFoundException();} else {return defineClass(name, result, 0, result.length);}} catch (FileNotFoundException e) {e.printStackTrace();}throw new ClassNotFoundException();}private byte[] getClassFromCustomPath(String name) {//细节略//根据路径读取二进制流的方式将指定类读取到内存中形成字节数组//如果指定路径的字节码文件进行了加,则需要在此方法中进行解密操作。return null;}public static void main(String[] args) {CustomClassLoader customClassLoader = new CustomClassLoader();try {Class<?> clazz = Class.forName("your class path", true, customClassLoader);Object obj = clazz.newInstance();System.out.println(obj.getClass().getClassLoader());} catch (Exception e) {e.printStackTrace();}}
}

关于ClassLoader

ClassLoader类,它是一个抽象类,其后所有的类加载器都继承自ClassLoader (不包括启动类加载器)

获取ClassLoader的途径

package com.dongguo.jvm02;/*** @author Dongguo* @date 2021/8/26 0026-10:18* @description: 获取ClassLoader*/
public class ClassLoader4 {public static void main(String[] args) {try {//第一种方法ClassLoader classLoader1 = Class.forName("java.lang.String").getClassLoader();System.out.println(classLoader1);//第二种ClassLoader classLoader2 = Thread.currentThread().getContextClassLoader();System.out.println(classLoader2);//第三种ClassLoader classLoader3 = ClassLoader.getSystemClassLoader().getParent();System.out.println(classLoader3);} catch (ClassNotFoundException e) {e.printStackTrace();}}
}
运行结果
null
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@1b6d3586

类加载器的特点

1.全盘负责：当一个类加载器加载一个类时，该类所依赖的其他类也会被这个类加载器加载到内存中。
2.缓存机制：所有的Class对象都会被缓存，当程序需要使用某个Class时，类加载器先从缓存中查找，找不到，才从class文件中读取数据，转化成Class对象，存入缓存中。

3.双亲委派机制

双亲委派机制

Java虚拟机对class文件采用的是按需加载的方式,也就是说当需要使用该类时才会将它的class文件加载到内存生成class对象。而且加载某个类的class文件时, Java虚拟机采用的是双亲委派模式,即把请求交由父类处理,它是一种任务委派模式。

工作原理

1)如果一个类加载器收到了类加载请求,它并不会自己先去加载,而是把这个请求委托给父类的加载器去执行

2)如果父类加载器还存在其父类加载器,则进一步向上委托,依次递归,请求最终将到达项层的启动类加载器;

3)如果父类加载器可以完成类加载任务,就成功返回,倘若父类加载器无法完成此加载任务,子加载器才会尝试自己去加载,这就是双亲委派模式。

自己创建一个java.lang.String类

package java.lang;/*** @author Dongguo* @date 2021/8/26 0026-11:22* @description: 自定义的String类*/
public class String {static {System.out.println("执行自定义的String类的静态代码快");}
}

调用自定义的String

package com.dongguo.jvm02;/*** @author Dongguo* @date 2021/8/26 0026-11:20* @description:*/
public class StringTest {public static void main(String[] args) {//如果使用自定义的String,会输出静态代码块的内容java.lang.String str = new java.lang.String();System.out.println("Hello JVM");}
}
运行结果：
Hello JVM

发现并没有输出自定义String类的静态代码块内容，说明并非使用的自定义的String类

没有加载自定义的String类，使用的还是核心api中的String类

尝试运行自定义的String类

package java.lang;/*** @author Dongguo* @date 2021/8/26 0026-11:22* @description: 自定义的String类*/
public class String {static {System.out.println("执行自定义的String类的静态代码快");}public static void main(String[] args) {System.out.println("启动自定义的String类");}
}

类加载器加载自定义的类的加载请求时，由于双亲委派机制，加载请求到达引导类加载器，引导类加载器会去加载Java核心库自带的String类，String类并没有main方法，因此报错

整个过程并没有加载自定义的java.lang.String类

反向委托

当类加载器加载第三方接口提供的jar时，

比如SPI接口，SPI属于核心api，首先通过双亲委托机制将类加载请求委托到引导类加载器，引用类加载器加载rt.jar 的SPI核心类，SPI接口中使用有第三方的jar包jdbc.jar。第三方的jar需要使用应用类加载器去加载，这个步骤就叫反向委派，通过线程上下文类加载器（通过调用当前线程的getContextClassLoader（）方法获得**Thread.currentThread().getContextClassLoader();**）线程上下文类加载器就是应用类加载器

优势

避免类的重复加载

保护程序安全,防止核心AP1被随意篡改

自定义类: java.lang.String

自定义类: java.lang.Shkstart

在自己创建的java.lang包下创建一个类Shkstart，运行

package java.lang;/*** @author Dongguo* @date 2021/8/26 0026-11:55* @description:*/
public class Shkstart {public static void main(String[] args) {System.out.println("hello");}
}

提示禁止使用包名java.lang，通过双亲委派机制引用类加载器加载Shkstart，发现Shkstart是自定义的类，为防止核心AP1被随意篡改，发生报错。

沙箱安全机制

自定义string类,但是在加载自定义string类的时候会率先使用引导类加载器加载,而引导类加载器在加载的过程中会先加载jdk自带的文件’(rt.jar包中java\lang\string.class) ,报错信息说没有main方法,就是因为加载的是rt.jar包中的string类。这样可以保证对java核心源代码的保护,这就是沙箱安全机制。