1. 什么是类加载
:::tips
简单来说，类加载就是将一个类的字节码文件加载到内存的过程，称为类的加载。
:::
类的生命周期
:::tips
加载 >> 验证 >> 准备 >> 解析 >> 初始化 >> 使用 >> 卸载
:::
- 加载：在硬盘上查找并通过IO读入字节码文件，使用到类时才会加载，
例如调用类的 main()方法，new对象等等，在加载阶段会在内存中生成一个代表这个类的 java.lang.Class对象，作为方法区这个类的各种数据的访问入口
- 验证：校验字节码文件的正确性
- 准备：给类的静态变量分配内存，并赋予默认值
- 解析：将符号引用替换为直接引用，该阶段会把一些静态方法(符号引用，比如 main()方法)替换为指向数据所存内存的指针或句柄等(直接引用)，这是所谓的静态链接过 程(类加载期间完成)，动态链接是在程序运行期间完成的将符号引用替换为直接引用
- 初始化：对类的静态变量初始化为指定的值，执行静态代码
类加载器
把实现类加载阶段中的“通过一个类的全限定名来获取描述此类的二进制字节流”这个动作的代码模块称为“类加载器”。
将 class 文件二进制数据放入方法区内，然后在堆内（heap）创建一个 java.lang.Class 对象，Class 对象封装了类在方法区内的数据结构，并且向开发者提供了访问方法区内的数据结构的接口。
目前类加载器却在类层次划分、OSGi、热部署、代码加密等领域非常重要，我们运行任何一个 Java 程序都会涉及到类加载器。
类的唯一性和类加载器
对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性。
注意，主类在运行过程中如果使用到其它类，会逐步加载这些类。 jar包或war包里的类不是一次性全部加载的，是使用到时才加载。
2. 什么是双亲委派
双亲委派概念
:::tips
加载某个类时会先委托父加载器寻找目标类，找不到再 委托上层父加载器加载，如果所有父加载器在自己的加载类路径下都找不到目标类，则在自己的 类加载路径中查找并载入目标类。
:::
双亲委派机制说简单点就是，先找父亲加载，不行再由儿子自己加载
总结:
- 子类先委托父类加载
- 父类加载器有自己的加载范围，范围内没有找到，则不加载，并返回给子类
- 子类在收到父类无法加载的时候，才会自己去加载
类加载源码-双亲委派源码解析
应用程序类加载器AppClassLoader加载类的双亲委派机制源码 AppClassLoader# 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) {//如果当前加载器父加载器不为空则委托父加载器加载该类c = parent.loadClass(name, false);} else {//如果当前加载器父加载器为空则委托引导类加载器加载该类c = findBootstrapClassOrNull(name);}} catch (ClassNotFoundException e) {}if (c == null) {long t1 = System.nanoTime();//如果bootstrapClassLoader 仍然没有加载过，则递归回来，尝试自己去加载class//最终都会调用URLClassLoader的findClass方法在加载器的类路径里查找并加载该类c = findClass(name);}}if (resolve) {resolveClass(c);}return c;}}
通过源码不难验证:
- 1.首先检查一下指定名称的类是否已经加载过，如果加载过了就不需要再加载直接返回。
- 如果此类没有加载过那么再判断一下是否有父加载器；如果有父加载器则由父加 载器加载（即调用 parent.loadClass(name, false);）.或者是调用bootstrap类加载器来加载。
- 如果父加载器及bootstrap类加载器都没有找到指定的类，那么调用当前类加载器的 findClass方法来完成类加载。
为什么要设计双亲委派机制？
- 沙箱安全机制：自己写的java.lang.String.class类不会被加载，这样便可以防止核心 API库被随意篡改
避免类的重复加载：当父亲已经加载了该类时，就没有必要子ClassLoader再加载一 次，保证被加载类的唯一性
3.如何自定义类加载器?
:::tips 自定义类加载器只需要继承 java.lang.ClassLoader 类，该类有两个核心方法
loadClass(String, boolean)，实现了双亲委派机制,重写此方法可以打破双亲委派
- findClass，默认实现是空方法,所以重写findClass方法可实现自定义类加载器
:::
自定义类加载器
自定义 MyClassLoader extends ClassLoader 重写 findClass 方法 实现自定义类加载器
class MyClassLoader extends ClassLoader {private final String classPath;public MyClassLoader(String classPath) {this.classPath = classPath;}@Overrideprotected Class<?> findClass(String name) throws ClassNotFoundException {try {byte[] data = loadByte(name);//defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节return defineClass(name, data, 0, data.length);} catch (Exception e) {e.printStackTrace();throw new ClassNotFoundException();}}private byte[] loadByte(String name) throws Exception {name = name.replaceAll("\\.", "/");FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");int len = fis.available();byte[] data = new byte[len];fis.read(data);fis.close();return data;}}public class MyClassLoaderTest{public static void main(String[] args) throws Exception{//初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载器设置为应用程序类加载器AppClassLoaderMyClassLoader classLoader = new MyClassLoader("D:/test");//D盘创建 com/itmck/springbootmq/demo 几级目录，将User类的复制类User1.class丢入该目录Class<?> clazz = classLoader.loadClass("com.itmck.springbootmq.demo.User");Object obj = clazz.newInstance();Method method = clazz.getDeclaredMethod("sout", null);method.invoke(obj, null);System.out.println(clazz.getClassLoader().getClass().getName());}}
如下所示User类
package com.itmck.springbootmq.demo;/*** 太阳当空照,花儿对我笑* <p>* Create by M ChangKe 2021/8/14 12:38**/public class User{public void sout(){System.out.println("hello...java");}}
运行结果
发现并没有走我们自定义的类.这就证明了先向上委托,此时委托的过程总被AppClassLoader加载,就不会再往下找
怎样才能走我们自定义的类加载器?
- 删除当前文件夹下的User.class
- package=com.itmck.springbootmq.demo所以创建如下层级将User.class放入
如下:将下面User.java编译成User.class.然后放入com/itmck/springbootmq/demo 文件夹下
package com.itmck.springbootmq.demo;public class User {public void sout(){System.out.println("hello");}}
运行结果:
由于向上委托并没有找打对应的User.class 此时才会由自己(MyClassLoader)去加载
4.如何打破双亲委派机制
由于:loadClass(String, boolean)，实现了双亲委派机制,重写此方法可以打破双亲委派
自定义 MyClassLoader extends ClassLoader 重写 loadClass(String, boolean)方法打破双亲委派
在上述代码的基础之上新增
@Overrideprotected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {synchronized (getClassLoadingLock(name)) {// First, check if the class has already been loadedClass<?> c = findLoadedClass(name);if (c == null) {long t0 = System.nanoTime();if (c == null) {long t1 = System.nanoTime();//========================改变这里打破双亲委派====================if (name.startsWith("com.itmck.springbootmq.demo")) {c = findClass(name);} else {c = this.getParent().loadClass(name);}//==================================================================// this is the defining class loader; record the statssun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);sun.misc.PerfCounter.getFindClasses().increment();}}if (resolve) {resolveClass(c);}return c;}}
运行结果:
由结果可知:
当前类加载器AppClassLoader下存在同名User.class但是没有被加载,仍然使用了自定义的类加载器去加载我们自定义的User.class.这也就是打破了双亲委派机制
5.Tomcat是如何打破双亲委派的
以Tomcat类加载为例，Tomcat 如果使用默认的双亲委派类加载机制行不行？
我们思考一下：Tomcat是个web容器， 那么它要解决什么问题：
- 一个web容器可能需要部署两个应用程序，不同的应用程序可能会依赖同一个第三方类库的 不同版本，不能要求同一个类库在同一个服务器只有一份，因此要保证每个应用程序的类库都是 独立的，保证相互隔离。
- 部署在同一个web容器中相同的类库相同的版本可以共享。否则，如果服务器有10个应用程 序，那么要有10份相同的类库加载进虚拟机。
- web容器也有自己依赖的类库，不能与应用程序的类库混淆。基于安全考虑，应该让容器的 类库和程序的类库隔离开来。
- web容器要支持jsp的修改，我们知道，jsp 文件最终也是要编译成class文件才能在虚拟机中 运行，但程序运行后修改jsp已经是司空见惯的事情， web容器需要支持 jsp 修改后不用重启。
再看看我们的问题：Tomcat 如果使用默认的双亲委派类加载机制行不行？ 答案是不行的。为什么？
- 第一个问题，如果使用默认的类加载器机制，那么是无法加载两个相同类库的不同版本的，默认 的类加器是不管你是什么版本的，只在乎你的全限定类名，并且只有一份。
- 第二个问题，默认的类加载器是能够实现的，因为他的职责就是保证唯一性。
- 第三个问题和第一个问题一样。
- 我们再看第四个问题，我们想我们要怎么实现jsp文件的热加载，jsp 文件其实也就是class文 件，那么如果修改了，但类名还是一样，类加载器会直接取方法区中已经存在的，修改后的jsp 是不会重新加载的。那么怎么办呢？我们可以直接卸载掉这jsp文件的类加载器，所以你应该想 到了，每个jsp文件对应一个唯一的类加载器，当一个jsp文件修改了，就直接卸载这个jsp类加载 器。重新创建类加载器，重新加载jsp文件。
若有收获，就点个赞吧
0 人点赞
