详解jvm之java类加载机制和类加载器(ClassLoader) 深入理解Java类加载器(ClassLoader) 如何自定义类加载器深入说明双亲委派双亲委派模型的破坏者-线程上下文类加载器

淡淡的烟草味﹌ 2023-09-28 18:24 83阅读 0赞

#### 目录 ####

*  引言
 *  类加载过程
 *   *  加载
     *  链接
     *  验证
     *  准备
     *  解析
     *  初始化
 *  类加载时机
 *  类加载器
 *   *  根类加载器（bootstrap class loader）
     *  扩展类加载器（extensions class loader）
     *  系统类加载器（system class loader）
 *  类加载机制
 *   *  全盘负责
     *  双亲委派
     *  缓存机制
 *  理解双亲委派模式
 *   *  双亲委派模式工作原理
     *  双亲委派模式优势
     *   *  loadClass(String)
         *  findClass(String)
         *  defineClass(byte\[\] b, int off, int len)
         *  resolveClass(Class≺?≻ c)
         *  重要说明
         *   *  SercureClassLoader
             *  URLClassLoader
             *  ExtClassLoader和AppClassLoader
 *  类加载器间的关系
 *  类与类加载器
 *   *  类与类加载器
     *  了解class文件的显示加载与隐式加载的概念
 *  自定义类加载器
 *   *  自定义类加载的目的
     *  自定义File类加载器
     *  自定义网络类加载器
     *  热部署类加载器
 *  双亲委派模型的破坏者-线程上下文类加载器
 *  参考文档

## 引言 ##

当程序主动使用某个类时，如果该类还未被加载到内存中，则JVM会通过加载、连接、初始化3个步骤来对该类进行初始化。

如果没有意外，JVM将会连续完成3个步骤，所以有时也把这个3个步骤统称为类加载或类初始化，如下图所示：

![在这里插入图片描述][c98cc5ff732945b785a60371c7ba2e8c.png]

## 类加载过程 ##

### 加载 ###

加载指的是将类的class文件读入到内存，并为之创建一个java.lang.Class对象，也就是说，当程序中使用任何类时，系统都会为之建立一个java.lang.Class对象。

类的加载由类加载器完成，类加载器通常由`JVM`提供，这些类加载器也是前面所有程序运行的基础，`JVM`提供的这些类加载器通常被称为系统类加载器。除此之外，开发者可以通过继承`ClassLoader`基类来创建自己的类加载器。

通过使用不同的类加载器，可以从不同来源加载类的二进制数据，通常有如下几种来源：

1.  从本地文件系统加载`class`文件，这是前面绝大部分示例程序的类加载方式。
2.  从JAR包加载class文件，这种方式也是很常见的，`JDBC`编程时用到的数据库驱动类就放在`JAR`文件中，`JVM`可以从`JAR`文件中直接加载该`class`文件。
3.  通过网络加载`class`文件。
4.  把一个`Java`源文件动态编译，并执行加载。

类加载器通常无须等到“首次使用”该类时才加载该类，`Java`虚拟机规范允许系统预先加载某些类。

### 链接 ###

当类被加载之后，系统为之生成一个对应的`Class`对象，接着将会进入连接阶段，连接阶段负责把类的二进制数据合并到`JRE`中。类连接又可分为如下3个阶段。

### 验证 ###

验证阶段用于检验被加载的类是否有正确的内部结构，并和其他类协调一致。

Java是相对C++语言是安全的语言，例如它有C++不具有的数组越界的检查。这本身就是对自身安全的一种保护。

验证阶段是Java非常重要的一个阶段，它会直接的保证应用是否会被恶意入侵的一道重要的防线，越是严谨的验证机制越安全。

验证的目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，不会危害虚拟机自身安全。其主要包括四种验证，文件格式验证，元数据验证，字节码验证，符号引用验证。

四种验证做进一步说明：

1.  文件格式验证  
    主要验证字节流是否符合Class文件格式规范，并且能被当前的虚拟机加载处理。例如：主，次版本号是否在当前虚拟机处理的范围之内。常量池中是否有不被支持的常量类型。指向常量的中的索引值是否存在不存在的常量或不符合类型的常量。
2.  元数据验证  
    对字节码描述的信息进行语义的分析，分析是否符合java的语言语法的规范。
3.  字节码验证  
    最重要的验证环节，分析数据流和控制，确定语义是合法的，符合逻辑的。主要的针对元数据验证后对方法体的验证。保证类方法在运行时不会有危害出现。
4.  符号引用验证  
    主要是针对符号引用转换为直接引用的时候，是会延伸到第三解析阶段，主要去确定访问类型等涉及到引用的情况，主要是要保证引用一定会被访问到，不会出现类等无法访问的问题。

### 准备 ###

类准备阶段负责为类的静态变量分配内存，并设置默认初始值。

### 解析 ###

将类的二进制数据中的符号引用替换成直接引用。

*  符号引用：以一组符号来描述所引用的目标，符号可以是任何的字面形式的字面量，只要不会出现冲突能够定位到就行。布局和内存无关。
 *  直接引用：是指向目标的指针，偏移量或者能够直接定位的句柄。该引用是和内存中的布局有关的，并且一定加载进来的。

### 初始化 ###

初始化是为类的静态变量赋予正确的初始值，准备阶段和初始化阶段看似有点矛盾，其实是不矛盾的。

如果类中有语句：private static int a = 10，它的执行过程是这样的：

1.  首先字节码文件被加载到内存后。
2.  先进行链接的验证这一步骤。
3.  验证通过后准备阶段。
4.  给a分配内存，因为变量a是static的，所以此时`a`等于`int`类型的默认初始值0，即`a=0`,然后到解析（后面在说），到初始化这一步骤时，才把`a`的真正的值`10`赋给`a`，此时`a=10`。

## 类加载时机 ##

*  创建类的实例，也就是new一个对象。
 *  访问某个类或接口的静态变量，或者对该静态变量赋值。
 *  调用类的静态方法。
 *  反射（`Class.forName("com.mysql.jdbc.Driver")`）
 *  初始化一个类的子类（会首先初始化子类的父类）
 *  JVM启动时标明的启动类，即文件名和类名相同的那个类

**除此之外，下面几种情形需要特别指出：**

对于一个final类型的静态变量，如果该变量的值在编译时就可以确定下来，那么这个变量相当于“宏变量”。

Java编译器会在编译时直接把这个变量出现的地方替换成它的值，因此即使程序使用该静态变量，也不会导致该类的初始化。

反之，如果final类型的静态Field的值不能在编译时确定下来，则必须等到运行时才可以确定该变量的值，如果通过该类来访问它的静态变量，则会导致该类被初始化。

## 类加载器 ##

类加载器负责加载所有的类，其为所有被载入内存中的类生成一个java.lang.Class实例对象。

一旦一个类被加载如JVM中，同一个类就不会被再次载入了。正如一个对象有一个唯一的标识一样，一个载入JVM的类也有一个唯一的标识。

在Java中，一个类用其全限定类名（包括包名和类名）作为标识。但在JVM中，一个类用其全限定类名和其类加载器作为其唯一标识。

例如，如果在po的包中有一个名为`Student的类`，被`类加载器ClassLoader`的实例kl负责加载，则该Student类对应的Class对象在JVM中表示为(`Student.po.kl`)。这意味着两个类加载器加载的同名类：`Student.po.kl`和`Student.po.kl2`是不同的、它们所加载的类也是完全不同、互不兼容的。

JVM预定义有三种类加载器，当一个 JVM启动的时候，Java开始使用如下三种类加载器：

### 根类加载器（bootstrap class loader） ###

它用来加载 Java 的核心类，是用原生代码来实现的，并不继承自`java.lang.ClassLoader`（负责加载`$JAVA_HOME中jre/lib/rt.jar`里所有的class，由C++实现，不是ClassLoader子类）。

由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不允许直接通过引用进行操作。

下面程序可以获得根类加载器所加载的核心类库,并会看到本机安装的Java环境变量指定的jdk中提供的核心jar包路径：

package com.example.demo.classloader;
    
    import sun.misc.Launcher;
    import java.net.URL;
    
    /**
     * @author zs
     * @datetime 2022/8/4 14:43
     * @desc 演示根类加载器
     */
    public class ClassLoaderTest {
        
      public static void main(String[] args) {
        
        URL[] urls = Launcher.getBootstrapClassPath().getURLs();
        for (URL url : urls) {
        
          System.out.println(url.toExternalForm());
        }
      }
    }

运行结果如下图：

![在这里插入图片描述][c602ab9749704ebdba0f3bdb28faa57a.png]

### 扩展类加载器（extensions class loader） ###

它负责加载JRE的扩展目录，`lib/ext或者由java.ext.dirs系统属性`指定的目录中的JAR包的类。由Java语言实现，父类加载器为null。

### 系统类加载器（system class loader） ###

被称为系统（也称为应用）类加载器，它负责在JVM启动时加载来自Java命令的`-classpath`选项、`java.class.path`系统属性，或者`CLASSPATH`换将变量所指定的JAR包和类路径。

程序可以通过`ClassLoader`的静态方法`getSystemClassLoader()`来获取系统类加载器。

如果没有特别指定，则用户自定义的类加载器都以此类加载器作为父加载器。由Java语言实现，父类加载器为`ExtClassLoader`。

**类加载器加载Class大致要经过如下8个步骤：**

1.  检测此Class是否载入过，即在缓冲区中是否有此Class，如果有直接进入第8步，否则进入第2步。
2.  如果没有父类加载器，则要么Parent是根类加载器，要么本身就是根类加载器，则跳到第4步，如果父类加载器存在，则进入第3步。
3.  请求使用父类加载器去载入目标类，如果载入成功则跳至第8步，否则接着执行第5步。
4.  请求使用根类加载器去载入目标类，如果载入成功则跳至第8步，否则跳至第7步。
5.  当前类加载器尝试寻找Class文件，如果找到则执行第6步，如果找不到则执行第7步。
6.  从文件中载入Class，成功后跳至第8步。
7.  抛出`ClassNotFountException`异常。
8.  返回对应的`java.lang.Class`对象。

## 类加载机制 ##

JVM的类加载机制主要有如下3种：

### 全盘负责 ###

所谓全盘负责，就是当一个类加载器负责加载某个Class时，该Class所依赖和引用其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入。

### 双亲委派 ###

所谓的双亲委派，则是先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类。

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

### 缓存机制 ###

缓存机制将会保证所有加载过的Class都会被缓存，当程序中需要使用某个Class时，类加载器先从缓存区中搜寻该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存入缓冲区中。这就是为很么修改了Class后，必须重新启动JVM，程序所做的修改才会生效的原因。

## 理解双亲委派模式 ##

### 双亲委派模式工作原理 ###

双亲委派模式要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器，请注意双亲委派模式中的父子关系并非通常所说的类继承关系，而是采用组合关系来复用父类加载器的相关代码，类加载器间的关系如下：

![在这里插入图片描述][06f5c076092f4197bbe37457846b801f.png]

双亲委派模式是在Java 1.2后引入的，其工作原理的是，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，即每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子自己想办法去完成，这不就是传说中的实力坑爹啊？那么采用这种模式有啥用呢?

### 双亲委派模式优势 ###

采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关可以避免类的重复加载，当父亲已经加载了该类时，就没有必要子`ClassLoader`再加载一次。

其次是考虑到安全因素，`java核心api`中定义类型不会被随意替换，假设通过网络传递一个名为`java.lang.Integer`的类，通过双亲委托模式传递到启动类加载器，而启动类加载器在核心Java API发现这个名字的类，发现该类已被加载，并不会重新加载网络传递的过来的`java.lang.Integer`，而直接返回已加载过的Integer.class，这样便可以防止核心API库被随意篡改。

可能你会想，如果我们在`classpath`路径下自定义一个名为`java.lang.StringInteger类`呢？如下代码所示：

package java.lang;
    
    /**
     * @author zs
     * @datetime 2022/8/4 15:23
     * @desc
     */
    public class StringInteger {
        
      public static void main(String[] args) {
        
        System.out.println(new StringInteger());
      }
    }

`StringInteger`类并不存在java.lang中，经过双亲委托模式，传递到启动类加载器中，由于父类加载器路径下并没有该类，所以不会加载，将反向委托给子类加载器加载，最终会通过系统类加载器加载该类。但是这样做是不允许，因为`java.lang是核心API包`，需要访问权限，强制加载将会报出如下异常：

![在这里插入图片描述][e0c26513c4d14eabb09d701120a39b8b.png]  
所以无论如何都无法加载成功的。

下面我们从代码层面了解几个Java中定义的类加载器及其双亲委派模式的实现，它们类图关系如下：

![在这里插入图片描述][326e16b419f2494ba23944124c683a99.png]  
从图可以看出顶层的类加载器是`ClassLoader类`，它是一个抽象类，其后所有的类加载器都继承自`ClassLoader`（不包括启动类加载器），这里我们主要介绍`ClassLoader`中几个比较重要的方法。

#### loadClass(String) ####

该方法加载指定名称（包括包名）的二进制类型，该方法在`JDK1.2`之后不再建议用户重写但用户可以直接调用该方法，`loadClass()`方法是`ClassLoader类`自己实现的，该方法中的逻辑就是双亲委派模式的实现，其源码如下：

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        
        synchronized (getClassLoadingLock(name)) {
        
            // 先从缓存查找该class对象，找到就不用重新加载
            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) {
        
                    // If still not found, then invoke findClass in order
                    // 如果都没有找到，则通过自定义实现的findClass去查找并加载
                    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;
        }
    }

`loadClass(String name, boolean resolve)`是一个重载方法，resolve参数代表是否生成class对象的同时进行解析相关操作。

正如`loadClass方法`所展示的，当类加载请求到来时，先从缓存中查找该类对象，如果存在直接返回，如果不存在则交给该类加载去的父加载器去加载，倘若没有父加载则交给顶级启动类加载器去加载，最后倘若仍没有找到，则使用`findClass()方法`去加载。

从loadClass实现也可以知道如果不想重新定义加载类的规则，也没有复杂的逻辑，只想在运行时加载自己指定的类，那么我们可以直接使用`this.getClass().getClassLoder.loadClass("className")`，这样就可以直接调用`ClassLoader的loadClass方法`获取到class对象。

#### findClass(String) ####

在`JDK1.2`之前，在自定义类加载时，总会去继承`ClassLoader类`并重写`loadClass方法`，从而实现自定义的类加载类，但是在JDK1.2之后已不再建议用户去覆盖`loadClass()`方法，而是建议把自定义的类加载逻辑写在`findClass()`方法中，从前面的分析可知，`findClass()`方法是在`loadClass()`方法中被调用的，当`loadClass()`方法中父加载器加载失败后，则会调用自己的`findClass()`方法来完成类加载，这样就可以保证自定义的类加载器也符合双亲委托模式。

需要注意的是`ClassLoader类`中并没有实现`findClass()方法`的具体代码逻辑，取而代之的是`抛出ClassNotFoundException异常`，同时应该知道的是findClass方法通常是和defineClass方法一起使用的(稍后会分析)，ClassLoader类中findClass()方法源码如下：

//直接抛出异常
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        
            throw new ClassNotFoundException(name);
    }

#### defineClass(byte\[\] b, int off, int len) ####

defineClass()方法是用来将byte字节流解析成JVM能够识别的Class对象(ClassLoader中已实现该方法逻辑)。通过这个方法不仅能够通过class文件实例化class对象，也可以通过其他方式实例化class对象，如通过网络接收一个类的字节码，然后转换为byte字节流创建对应的Class对象。

`defineClass()方法通常与findClass()方法一起使用`，一般情况下，在自定义类加载器时，会直接覆盖ClassLoader的findClass()方法并编写加载规则，取得要加载类的字节码后转换成流，然后调用defineClass()方法生成类的Class对象，简单例子如下：

protected Class<?> findClass(String name) throws ClassNotFoundException {
        
     // 获取类的字节数组
        byte[] classData = getClassData(name);  
        if (classData == null) {
        
            throw new ClassNotFoundException();
        } else {
        
         //使用defineClass生成class对象
            return defineClass(name, classData, 0, classData.length);
        }
    }

**需要注意的是，如果直接调用defineClass()方法生成类的Class对象，这个类的Class对象并没有解析(也可以理解为链接阶段，毕竟解析是链接的最后一步)，其解析操作需要等待初始化阶段进行。**

#### resolveClass(Class≺?≻ c) ####

使用该方法可以使用类的Class对象创建完成也同时被解析。

前面我们说链接阶段主要是对字节码进行验证，为类变量分配内存并设置初始值同时将字节码文件中的符号引用转换为直接引用。

#### 重要说明 ####

上述4个方法是ClassLoader类中的比较重要的方法，也是我们可能会经常用到的方法。

##### SercureClassLoader #####

j接着看SercureClassLoader，它扩展了 ClassLoader，新增了几个与使用相关的代码源(对代码源的位置及其证书的验证)和权限定义类验证(主要指对class源码的访问权限)的方法，一般我们不会直接跟这个类打交道，更多是与它的子类URLClassLoader有所关联，前面说过，ClassLoader是一个抽象类，很多方法是空的没有实现，比如 findClass()、findResource()等。

##### URLClassLoader #####

而URLClassLoader这个实现类为这些方法提供了具体的实现，并新增了URLClassPath类协助取得Class字节码流等功能，在编写自定义类加载器时，如果没有太过于复杂的需求，可以直接继承URLClassLoader类，这样就可以避免自己去编写findClass()方法及其获取字节码流的方式，使自定义类加载器编写更加简洁，下面是URLClassLoader的类图：

![在这里插入图片描述][93fea18870154255bd831f55cb08002e.png]  
从类图结构看出URLClassLoader中存在一个URLClassPath类，通过这个类就可以找到要加载的字节码流，也就是说URLClassPath类负责找到要加载的字节码，再读取成字节流，最后通过defineClass()方法创建类的Class对象。

从URLClassLoader类的结构图可以看出其构造方法都有一个必须传递的参数URL\[\]，该参数的元素是代表字节码文件的路径,换句话说在创建URLClassLoader对象时必须要指定这个类加载器的到那个目录下找class文件。同时也应该注意URL\[\]也是URLClassPath类的必传参数，在创建URLClassPath对象时，会根据传递过来的URL数组中的路径判断是文件还是jar包，然后根据不同的路径创建FileLoader或者JarLoader或默认Loader类去加载相应路径下的class文件，而当JVM调用findClass()方法时，就由这3个加载器中的一个将class文件的字节码流加载到内存中，最后利用字节码流创建类的class对象。

**请记住，如果我们在定义类加载器时选择继承ClassLoader类而非URLClassLoader，必须手动编写findclass()方法的加载逻辑以及获取字节码流的逻辑。**

##### ExtClassLoader和AppClassLoader #####

了解完URLClassLoader后接着看看剩余的两个类加载器，即拓展类加载器`ExtClassLoader和系统类加载器AppClassLoader`，这两个类都继承自URLClassLoader，是`sun.misc.Launcher`的静态内部类。`sun.misc.Launcher`主要被系统用于启动主应用程序，ExtClassLoader和AppClassLoader都是由`sun.misc.Launcher`创建的，其类主要类结构如下：

![在这里插入图片描述][76a50e4688904d46b3be7720074ce823.png]

它们间的关系正如前面所阐述的那样，同时我们发现`ExtClassLoade`r并没有重写loadClass()方法，这足矣说明其遵循双亲委派模式，而`AppClassLoader`重载了loadCass()方法，但最终调用的还是父类loadClass()方法，因此依然遵守双亲委派模式，重载方法源码如下：

/**
     * Override loadClass 方法，新增包权限检测功能
     */
    public Class loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        
        int i = name.lastIndexOf('.');
        if (i != -1) {
        
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
        
                sm.checkPackageAccess(name.substring(0, i));
            }
        }
        //依然调用父类的方法
        return (super.loadClass(name, resolve));
    }

其实无论是ExtClassLoader还是AppClassLoader都继承URLClassLoader类，因此它们都遵守双亲委托模型，这点是毋庸置疑的。

到此，我们对`ClassLoader、URLClassLoader、ExtClassLoader、AppClassLoader以及Launcher类间的关系有了比较清晰的了解`，同时对一些主要的方法也有一定的认识，这里并没有对这些类的源码进行详细的分析，毕竟没有那个必要，因为我们主要弄得类与类间的关系和常用的方法同时搞清楚双亲委托模式的实现过程，为编写自定义类加载器做铺垫就足够了。

前面出现了很多父类加载器的说法，但每个类加载器的父类到底是谁，一直没有阐明，下面我们就通过代码验证的方式来阐明这答案。

## 类加载器间的关系 ##

我们进一步了解类加载器间的关系(并非指继承关系)，主要可以分为以下4点

1.  启动类加载器，由C++实现，没有父类。
2.  拓展类加载器(ExtClassLoader)，由Java语言实现，父类加载器为null
3.  系统类加载器(AppClassLoader)，由Java语言实现，父类加载器为ExtClassLoader
4.  自定义类加载器，父类加载器肯定为AppClassLoader。

下面我们通过程序来验证上述阐述的观点：

package com.example.demo.classloader;
    
    /**
     * @author zs
     * @datetime 2022/8/4 15:47
     * @desc 自定义ClassLoader
     */
    public class FileClassLoader extends ClassLoader {
        
      private String rootDir;
    
      public FileClassLoader(String rootDir) {
        
        this.rootDir = rootDir;
      }
    
      /**
       * @author zs
       * @datetime 2022/8/4:15:48
       * @desc 编写获取类的字节码并创建class对象的逻辑
       */
      @Override
      protected Class<?> findClass(String name) {
        
        return null;
      }
    
      /**
       * @author zs
       * @datetime 2022/8/4:15:48
       * @desc 编写读取字节流的方法
       */
      private byte[] getClassData(String className) {
        
        return null;
      }
    
      public static void main(String[] args) {
        
        FileClassLoader loader1 = new FileClassLoader("C:\\Users\\zs\\Desktop");
    
        System.out.println("自定义类加载器的父加载器: " + loader1.getParent());
        System.out.println("系统默认的AppClassLoader: " + ClassLoader.getSystemClassLoader());
        System.out.println("AppClassLoader的父类加载器: " + ClassLoader.getSystemClassLoader().getParent());
        System.out.println(
            "ExtClassLoader的父类加载器: " + ClassLoader.getSystemClassLoader().getParent().getParent());
      }
    }

输出结果：

![在这里插入图片描述][051a14b4e2ab4968b84b9b1a3604fb4a.png]

代码中，我们自定义了一个`FileClassLoader`，这里我们继承了ClassLoader而非URLClassLoader，因此需要自己编写findClass()方法逻辑以及加载字节码的逻辑，关于自定义类加载器我们稍后会分析，这里仅需要知道FileClassLoader是自定义加载器即可。

接着在main方法中，通过`ClassLoader.getSystemClassLoader()`获取到系统默认类加载器，通过获取其父类加载器及其父父类加载器，同时还获取了自定义类加载器的父类加载器,最终输出结果正如我们所预料的：`AppClassLoader的父类加载器为ExtClassLoader，而ExtClassLoader没有父类加载器。如果我们实现自己的类加载器，它的父加载器都只会是AppClassLoader。`

这里我们不妨看看Lancher的构造器源码：

public Launcher() {
        
        // 首先创建拓展类加载器
        ClassLoader extcl;
        try {
        
            extcl = ExtClassLoader.getExtClassLoader();
        } catch (IOException e) {
        
            throw new InternalError(
                "Could not create extension class loader");
        }
    
        // Now create the class loader to use to launch the application
        try {
        
         //再创建AppClassLoader并把extcl作为父加载器传递给AppClassLoader
            loader = AppClassLoader.getAppClassLoader(extcl);
        } catch (IOException e) {
        
            throw new InternalError(
                "Could not create application class loader");
        }
    
        //设置线程上下文类加载器，稍后分析
        Thread.currentThread().setContextClassLoader(loader);
    //省略其他没必要的代码......
        }
    }

显然Lancher初始化时首先会创建ExtClassLoader类加载器，然后再创建AppClassLoader并把ExtClassLoader传递给它作为父类加载器，这里还把AppClassLoader默认设置为线程上下文类加载器，关于线程上下文类加载器稍后会分析。那ExtClassLoader类加载器为什么是null呢？看下面的源码创建过程就明白，在创建ExtClassLoader强制设置了其父加载器为null。

//Lancher中创建ExtClassLoader
    extcl = ExtClassLoader.getExtClassLoader();
    
    //getExtClassLoader()方法
    public static ExtClassLoader getExtClassLoader() throws IOException{
        
    	//........省略其他代码 
    	return new ExtClassLoader(dirs);                     
    	// .........
    }
    
    //构造方法
    public ExtClassLoader(File[] dirs) throws IOException {
        
    	//调用父类构造URLClassLoader传递null作为parent
    	super(getExtURLs(dirs), null, factory);
    }
    
    //URLClassLoader构造
    public URLClassLoader(URL[] urls, ClassLoader parent,
    	URLStreamHandlerFactory factory) {
        
    }

显然`ExtClassLoader`的父类为null，而`AppClassLoader的父加载器为ExtClassLoader`，所有自定义的类加载器其父加载器只会是AppClassLoader，**注意这里所指的父类并不是Java继承关系中的那种父子关系。**

## 类与类加载器 ##

### 类与类加载器 ###

在JVM中表示两个class对象是否为同一个类对象存在两个必要条件：

*  类的完整类名必须一致，包括包名。
 *  加载这个类的ClassLoader(指ClassLoader实例对象)必须相同。

也就是说，在JVM中，即使这个两个类对象(class对象)来源同一个Class文件，被同一个虚拟机所加载，但只要加载它们的ClassLoader实例对象不同，那么这两个类对象也是不相等的。

这是因为不同的ClassLoader实例对象都拥有不同的独立的类名称空间，所以加载的class对象也会存在不同的类名空间中，但前提是覆写loadclass方法，从前面双亲委派模式对loadClass()方法的源码分析中可以知，在方法第一步会通过`Class<?> c = findLoadedClass(name)`。

从缓存查找，类名完整名称相同则不会再次被加载，因此我们必须绕过缓存查询才能重新加载class对象。当然也可直接调用findClass()方法，这样也避免从缓存查找，如下：

String rootDir="/Users/zejian/Downloads/Java8_Action/src/main/java/";
    //创建两个不同的自定义类加载器实例
    FileClassLoader loader1 = new FileClassLoader(rootDir);
    FileClassLoader loader2 = new FileClassLoader(rootDir);
    //通过findClass创建类的Class对象
    Class<?> object1=loader1.findClass("com.zejian.classloader.DemoObj");
    Class<?> object2=loader2.findClass("com.zejian.classloader.DemoObj");
    
    System.out.println("findClass->obj1:"+object1.hashCode());
    System.out.println("findClass->obj2:"+object2.hashCode());
    
    /**
      * 直接调用findClass方法输出结果:
      * findClass->obj1:723074861
        findClass->obj2:895328852
        生成不同的实例
      */

如果调用父类的loadClass方法，结果如下，除非重写loadClass()方法去掉缓存查找步骤，不过现在一般都不建议重写loadClass()方法。

//直接调用父类的loadClass()方法
    Class<?> obj1 =loader1.loadClass("com.zejian.classloader.DemoObj");
    Class<?> obj2 =loader2.loadClass("com.zejian.classloader.DemoObj");
    
    //不同实例对象的自定义类加载器
    System.out.println("loadClass->obj1:"+obj1.hashCode());
    System.out.println("loadClass->obj2:"+obj2.hashCode());
    //系统类加载器
    System.out.println("Class->obj3:"+DemoObj.class.hashCode());
    
    /**
    * 直接调用loadClass方法的输出结果,注意并没有重写loadClass方法
    * loadClass->obj1:1872034366
      loadClass->obj2:1872034366
      Class->    obj3:1872034366
      都是同一个实例
    */

所以如果不从缓存查询相同完全类名的class对象，那么只有ClassLoader的实例对象不同，同一字节码文件创建的class对象自然也不会相同。

### 了解class文件的显示加载与隐式加载的概念 ###

所谓class文件的显示加载与隐式加载的方式是指JVM加载class文件到内存的方式：

*  显示加载指的是在代码中通过调用`ClassLoader加载class对象`，如直接使用`Class.forName(name)`或`this.getClass().getClassLoader().loadClass()`加载class对象。
 *  隐式加载则是不直接在代码中调用ClassLoader的方法加载class对象，而是通过虚拟机自动加载到内存中，如在加载某个类的class文件时，该类的class文件中引用了另外一个类的对象，此时额外引用的类将通过JVM自动加载到内存中。

在日常开发以上两种方式一般会混合使用，这里我们知道有这么回事即可。

## 自定义类加载器 ##

通过前面的分析可知，实现自定义类加载器需要继承ClassLoader或者URLClassLoader，继承ClassLoader则需要自己重写findClass()方法并编写加载逻辑，继承URLClassLoader则可以省去编写findClass()方法以及class文件加载转换成字节码流的代码。

### 自定义类加载的目的 ###

那么编写自定义类加载器的意义何在呢？

*  当class文件不在ClassPath路径下，默认系统类加载器无法找到该class文件，在这种情况下我们需要实现一个自定义的ClassLoader来加载特定路径下的class文件生成class对象。
 *  当一个class文件是通过网络传输并且可能会进行相应的加密操作时，需要先对class文件进行相应的解密后再加载到JVM内存中，这种情况下也需要编写自定义的ClassLoader并实现相应的逻辑。
 *  当需要实现热部署功能时(一个class文件通过不同的类加载器产生不同class对象从而实现热部署功能)，需要实现自定义ClassLoader的逻辑。

### 自定义File类加载器 ###

这里我们继承ClassLoader实现自定义的特定路径下的文件类加载器并加载编译后`DemoObj.class`，源码代码如下：

package com.example.demo.classloader;
    
    /**
     * @author zs
     * @datetime 2022/8/4 16:09
     * @desc 我是演示类
     */
    public class Demo {
        
    
      @Override
      public String toString() {
        
        return "我是演示类";
      }
    }

package com.example.demo.classloader;
    
    import java.io.*;
    
    /**
     * @author zs
     * @datetime 2022/8/4 15:47
     * @desc 自定义类加载器
     */
    public class FileClassLoader extends ClassLoader {
        
      private String rootDir;
    
      public FileClassLoader(String rootDir) {
        
        this.rootDir = rootDir;
      }
    
      /**
       * @author zs
       * @datetime 2022/8/4:16:12
       * @desc 编写findClass方法的逻辑
       */
      @Override
      protected Class<?> findClass(String name) throws ClassNotFoundException {
        
        // 获取类的class文件字节数组
        byte[] classData = getClassData(name);
        if (classData == null) {
        
          throw new ClassNotFoundException();
        } else {
        
          // 直接生成class对象
          return defineClass(name, classData, 0, classData.length);
        }
      }
    
    /**
     * @author zs
     * @datetime 2022/8/4:16:12
     * @desc  编写获取class文件并转换为字节码流的逻辑
     */
      private byte[] getClassData(String className) {
        
        // 读取类文件的字节
        String path = classNameToPath(className);
        try {
        
          InputStream ins = new FileInputStream(path);
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          int bufferSize = 4096;
          byte[] buffer = new byte[bufferSize];
          int bytesNumRead = 0;
          // 读取类文件的字节码
          while ((bytesNumRead = ins.read(buffer)) != -1) {
        
            baos.write(buffer, 0, bytesNumRead);
          }
          return baos.toByteArray();
        } catch (IOException e) {
        
          e.printStackTrace();
        }
        return null;
      }
    
      /**
       * 类文件的完全路径
       *
       * @param className
       * @return
       */
      private String classNameToPath(String className) {
        
        return rootDir + File.separatorChar + className.replace('.', File.separatorChar) + ".class";
      }
    
      public static void main(String[] args) {
        
    
        String rootDir = "D:/project/demo/target/classes";
        // 创建自定义文件类加载器
        FileClassLoader loader = new FileClassLoader(rootDir);
    
        try {
        
          // 加载指定的class文件
          Class<?> object1 = loader.loadClass("com.example.demo.classloader.Demo");
          System.out.println(object1.newInstance().toString());
    
          // 输出结果:我是演示类
        } catch (Exception e) {
        
          e.printStackTrace();
        }
      }
    }

输出结果为：

![在这里插入图片描述][b215e8945bfd4c86910bc189d3153d77.png]

注意，`rootDir`是你得`Demo.class文件`的根路径；`loadClass`的形参是你的类名，不要有任何空格。否则会报出**系统找不到指定的路径**，如下图所示：

![在这里插入图片描述][339a8a40a87b498b898ab2962d6bf274.png]

显然我们通过`getClassData()方法`找到class文件并转换为字节流，并重写`findClass()方法`，利用`defineClass()方法`创建了类的class对象。

在main方法中调用了loadClass()方法加载指定路径下的class文件，由于启动类加载器、拓展类加载器以及系统类加载器都无法在其路径下找到该类，因此最终将有自定义类加载器加载，即调用findClass()方法进行加载。

如果继承URLClassLoader实现，那代码就更简洁了，如下：

package com.example.demo.classloader;
    
    import java.io.File;
    import java.net.*;
    
    /**
     * @author zs
     * @datetime 2022/8/4 16:30
     * @desc 自定义URLClassLoader类加载
     */
    public class FileUrlClassLoader extends URLClassLoader {
        
    
        public FileUrlClassLoader(URL[] urls) {
        
            super(urls);
        }
    
        public static void main(String[] args) throws MalformedURLException {
        
            String rootDir="D:/project/demo/target/classes";
            //创建自定义文件类加载器
            File file = new File(rootDir);
            //File to URI
            URI uri=file.toURI();
            URL[] urls={
        uri.toURL()};
    
            FileUrlClassLoader loader = new FileUrlClassLoader(urls);
    
            try {
        
                //加载指定的class文件
                Class<?> object1=loader.loadClass("com.example.demo.classloader.Demo");
                System.out.println(object1.newInstance().toString());
    
                //输出结果:我是演示类
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

输出结果为：

![在这里插入图片描述][fa99e54437ce46e1b0a8de1f72836edd.png]

非常简洁除了需要重写构造器外无需编写findClass()方法及其class文件的字节流转换逻辑。

### 自定义网络类加载器 ###

自定义网络类加载器，主要用于读取通过网络传递的class文件（在这里我们省略class文件的解密过程），并将其转换成字节流生成对应的class对象，如下：

package com.example.demo.classloader;
    
    import java.io.ByteArrayOutputStream;
    import java.io.InputStream;
    import java.net.URL;
    
    /**
     * @author zs
     * @datetime 2022/8/4 16:52
     * @desc 自定义网络类加载器
     */
    public class NetClassLoader extends ClassLoader {
        
    
      /** class文件的URL */
      private String url;
    
      @Override
      protected Class<?> findClass(String name) throws ClassNotFoundException {
        
        byte[] classData = getClassDataFromNet(name);
        if (classData == null) {
        
          throw new ClassNotFoundException();
        } else {
        
          return defineClass(name, classData, 0, classData.length);
        }
      }
    
      /**
       * @author zs
       * @datetime 2022/8/4:16:54
       * @desc 从网络获取class文件
       */
      private byte[] getClassDataFromNet(String className) {
        
        String path = classNameToPath(className);
        try {
        
          URL url = new URL(path);
          InputStream ins = url.openStream();
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          int bufferSize = 4096;
          byte[] buffer = new byte[bufferSize];
          int bytesNumRead = 0;
          // 读取类文件的字节
          while ((bytesNumRead = ins.read(buffer)) != -1) {
        
            baos.write(buffer, 0, bytesNumRead);
          }
          // 这里省略解密的过程.......
          return baos.toByteArray();
        } catch (Exception e) {
        
          e.printStackTrace();
        }
        return null;
      }
    
      /**
       * @author zs
       * @datetime 2022/8/4:16:54
       * @desc 类名转化为路径
       */
      private String classNameToPath(String className) {
        
        // 得到类文件的URL
        return url + "/" + className.replace('.', '/') + ".class";
      }
    }

比较简单，主要是在获取字节码流时的区别，从网络直接获取到字节流再转车字节数组然后利用defineClass方法创建class对象，如果继承URLClassLoader类则和前面文件路径的实现是类似的，无需担心路径是filePath还是Url，因为URLClassLoader内的URLClassPath对象会根据传递过来的URL数组中的路径判断是文件还是jar包，然后根据不同的路径创建FileLoader或者JarLoader或默认类Loader去读取对于的路径或者url下的class文件。

### 热部署类加载器 ###

所谓的热部署就是利用同一个class文件不同的类加载器在内存创建出两个不同的class对象(关于这点的原因前面已分析过，即利用不同的类加载实例)，由于JVM在加载类之前会检测请求的类是否已加载过(即在loadClass()方法中调用findLoadedClass()方法)，如果被加载过，则直接从缓存获取，不会重新加载。

**注意同一个类加载器的实例和同一个class文件只能被加载器一次，多次加载将报错。**

因此，我们实现的热部署必须让同一个class文件可以根据不同的类加载器重复加载，以实现所谓的热部署。

实际上前面的实现的`FileClassLoader和FileUrlClassLoader`已具备这个功能，但前提是直接调用findClass()方法，而不是调用loadClass()方法，因为ClassLoader中loadClass()方法体中调用findLoadedClass()方法进行了检测是否已被加载，因此我们直接调用findClass()方法就可以绕过这个问题，当然也可以重新loadClass方法，但强烈不建议这么干。

利用FileClassLoader类测试代码如下：

public static void main(String[] args) {
        
      String rootDir = "D:/project/demo/target/classes";
      // 创建自定义文件类加载器
      FileClassLoader loader = new FileClassLoader(rootDir);
      FileClassLoader loader2 = new FileClassLoader(rootDir);
    
      try {
        
        // 加载指定的class文件,调用loadClass()
        Class<?> object1 = loader.loadClass("com.example.demo.classloader.Demo");
        Class<?> object2 = loader2.loadClass("com.example.demo.classloader.Demo");
    
        System.out.println("loadClass->obj1:" + object1.hashCode());
        System.out.println("loadClass->obj2:" + object2.hashCode());
    
        // 加载指定的class文件,直接调用findClass(),绕过检测机制，创建不同class对象。
        Class<?> object3 = loader.findClass("com.example.demo.classloader.Demo");
        Class<?> object4 = loader2.findClass("com.example.demo.classloader.Demo");
    
        System.out.println("loadClass->obj3:" + object3.hashCode());
        System.out.println("loadClass->obj4:" + object4.hashCode());
      } catch (Exception e) {
        
        e.printStackTrace();
      }
    }

输出结果为：  
![在这里插入图片描述][8f49353f8fac47d1856bc2b042d1b78b.png]

## 双亲委派模型的破坏者-线程上下文类加载器 ##

在Java应用中存在着很多`服务提供者接口（Service Provider Interface，SPI）`，这些接口允许第三方为它们提供实现，如常见的 SPI 有 JDBC、JNDI等，这些 SPI 的接口属于 Java 核心库，一般存在rt.jar包中，由Bootstrap类加载器加载，而 SPI 的第三方实现代码则是作为Java应用所依赖的 jar 包被存放在classpath路径下，由于SPI接口中的代码经常需要加载具体的第三方实现类并调用其相关方法，但SPI的核心接口类是由引导类加载器来加载的，而Bootstrap类加载器无法直接加载SPI的实现类，同时由于双亲委派模式的存在，Bootstrap类加载器也无法反向委托AppClassLoader加载器SPI的实现类。在这种情况下，我们就需要一种特殊的类加载器来加载第三方的类库，而线程上下文类加载器就是很好的选择。

`线程上下文类加载器（contextClassLoader）`是从 JDK 1.2 开始引入的，我们可以通过`java.lang.Thread`类中的`getContextClassLoader()和 setContextClassLoader(ClassLoader cl)方法`来获取和设置线程的上下文类加载器。如果没有手动设置上下文类加载器，线程将继承其父线程的上下文类加载器，初始线程的上下文类加载器是`系统类加载器（AppClassLoader）`,在线程中运行的代码可以通过此类加载器来加载类和资源，如下图所示，以jdbc.jar加载为例：

![在这里插入图片描述][088d123d58874a61a5722db3dc696d73.png]

从图可知rt.jar核心包是有Bootstrap类加载器加载的，其内包含SPI核心接口类，由于SPI中的类经常需要调用外部实现类的方法，而jdbc.jar包含外部实现类(jdbc.jar存在于classpath路径)无法通过Bootstrap类加载器加载。因此，只能委派线程上下文类加载器把jdbc.jar中的实现类加载到内存以便SPI相关类使用。

显然这种线程上下文类加载器的加载方式破坏了“双亲委派模型”，它在执行过程中抛弃双亲委派加载链模式，使程序可以逆向使用类加载器，当然这也使得Java类加载器变得更加灵活。

为了进一步证实这种场景，不妨看看DriverManager类的源码，DriverManager是Java核心rt.jar包中的类，该类用来管理不同数据库的实现驱动即Driver，它们都实现了Java核心包中的java.sql.Driver接口，如mysql驱动包中的com.mysql.jdbc.Driver，这里主要看看如何加载外部实现类，在DriverManager初始化时会执行如下代码：

//DriverManager是Java核心包rt.jar的类
    public class DriverManager {
        
    	//省略不必要的代码
        static {
        
            loadInitialDrivers();//执行该方法
            println("JDBC DriverManager initialized");
        }
    
    //loadInitialDrivers方法
     private static void loadInitialDrivers() {
        
         sun.misc.Providers()
         AccessController.doPrivileged(new PrivilegedAction<Void>() {
        
                public Void run() {
        
    				//加载外部的Driver的实现类
                    ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                  //省略不必要的代码......
                }
            });
        }

在DriverManager类初始化时执行了`loadInitialDrivers()`方法,在该方法中通过`ServiceLoader.load(Driver.class);`去加载外部实现的驱动类，`ServiceLoader类会去读取mysql的jdbc.jar下META-INF文件的内容`，如下所示：

![在这里插入图片描述][f08325216a6c422ba30669686d998829.png]

而`com.mysql.jdbc.Driver`继承类如下：

public class Driver extends com.mysql.cj.jdbc.Driver {
        
       public Driver() throws SQLException {
        
           super();
       }
    
       static {
        
           System.err.println("Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. "
                   + "The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.");
       }
    }

从注释可以看出平常我们使用`com.mysql.jdbc.Driver`已被丢弃了，取而代之的是`com.mysql.cj.jdbc.Driver`，也就是说官方不再建议我们使用如下代码注册mysql驱动

//不建议使用该方式注册驱动类
    Class.forName("com.mysql.jdbc.Driver");
    String url = "jdbc:mysql://localhost:3306/cm-storylocker?characterEncoding=UTF-8";
    // 通过java库获取数据库连接
    Connection conn = java.sql.DriverManager.getConnection(url, "root", "123456");

而是直接去掉注册步骤，如下即可：

String url = "jdbc:mysql://localhost:3306/cm-storylocker?characterEncoding=UTF-8";
    // 通过java库获取数据库连接
    Connection conn = java.sql.DriverManager.getConnection(url, "root", "root@555");

这样ServiceLoader会帮助我们处理一切，并最终通过load()方法加载，看看load()方法实现：

public static <S> ServiceLoader<S> load(Class<S> service) {
        
    	 //通过线程上下文类加载器加载
          ClassLoader cl = Thread.currentThread().getContextClassLoader();
          return ServiceLoader.load(service, cl);
      }

很明显了确实通过线程上下文类加载器加载的，实际上核心包的SPI类对外部实现类的加载都是基于线程上下文类加载器执行的，通过这种方式实现了Java核心代码内部去调用外部实现类。

我们知道线程上下文类加载器默认情况下就是AppClassLoader，那为什么不直接通过`getSystemClassLoader()`获取类加载器来加载classpath路径下的类的呢？

其实是可行的，但这种直接使用getSystemClassLoader()方法获取AppClassLoader加载类有一个缺点，那就是代码部署到不同服务时会出现问题，如把代码部署到Java Web应用服务或者EJB之类的服务将会出问题，因为这些服务使用的线程上下文类加载器并非AppClassLoader，而是Java Web应用服自家的类加载器，类加载器不同。

所以我们应用该少用getSystemClassLoader()。

总之不同的服务使用的可能默认ClassLoader是不同的，但使用线程上下文类加载器总能获取到与当前程序执行相同的ClassLoader，从而避免不必要的问题。

关于线程上下文类加载器暂且聊到这，前面阐述的DriverManager类，大家可以自行看看源码，相信会有更多的体会，另外关于ServiceLoader本篇并没有过多的阐述，毕竟我们主题是类加载器，但ServiceLoader是个很不错的解耦机制，大家可以自行查阅其相关用法。

## 参考文档 ##

1.  https://blog.csdn.net/m0\_38075425/article/details/81627349
2.  https://blog.csdn.net/javazejian/article/details/73413292

[c98cc5ff732945b785a60371c7ba2e8c.png]: https://img-blog.csdnimg.cn/c98cc5ff732945b785a60371c7ba2e8c.png
[c602ab9749704ebdba0f3bdb28faa57a.png]: https://img-blog.csdnimg.cn/c602ab9749704ebdba0f3bdb28faa57a.png
[06f5c076092f4197bbe37457846b801f.png]: https://img-blog.csdnimg.cn/06f5c076092f4197bbe37457846b801f.png
[e0c26513c4d14eabb09d701120a39b8b.png]: https://img-blog.csdnimg.cn/e0c26513c4d14eabb09d701120a39b8b.png
[326e16b419f2494ba23944124c683a99.png]: https://img-blog.csdnimg.cn/326e16b419f2494ba23944124c683a99.png
[93fea18870154255bd831f55cb08002e.png]: https://img-blog.csdnimg.cn/93fea18870154255bd831f55cb08002e.png
[76a50e4688904d46b3be7720074ce823.png]: https://img-blog.csdnimg.cn/76a50e4688904d46b3be7720074ce823.png
[051a14b4e2ab4968b84b9b1a3604fb4a.png]: https://img-blog.csdnimg.cn/051a14b4e2ab4968b84b9b1a3604fb4a.png
[b215e8945bfd4c86910bc189d3153d77.png]: https://img-blog.csdnimg.cn/b215e8945bfd4c86910bc189d3153d77.png
[339a8a40a87b498b898ab2962d6bf274.png]: https://img-blog.csdnimg.cn/339a8a40a87b498b898ab2962d6bf274.png
[fa99e54437ce46e1b0a8de1f72836edd.png]: https://img-blog.csdnimg.cn/fa99e54437ce46e1b0a8de1f72836edd.png
[8f49353f8fac47d1856bc2b042d1b78b.png]: https://img-blog.csdnimg.cn/8f49353f8fac47d1856bc2b042d1b78b.png
[088d123d58874a61a5722db3dc696d73.png]: https://img-blog.csdnimg.cn/088d123d58874a61a5722db3dc696d73.png
[f08325216a6c422ba30669686d998829.png]: https://img-blog.csdnimg.cn/f08325216a6c422ba30669686d998829.png