JVM系列(五) - JVM类加载机制详解

╰半橙微兮° 2022-05-15 02:28 290阅读 0赞

# 前言 #

本文将由浅及深，介绍`Java`类加载的过程和原理，进一步对类加载器的进行源码分析，完成一个自定义的类加载器。

![JVM_E7_B1_BB_E5_8A_A0_E8_BD_BD_E6_9C_BA_E5_88_B6.png][]

# 正文 #

## (一). 类加载器是什么 ##

类加载器简言之，就是用于把`.class`文件中的**字节码信息**转化为具体`的java.lang.Class`**对象**的过程的工具。

具体过程：

1.  在实际类加载过程中，`JVM`会将所有的`.class`字节码文件中的**二进制数据**读入内存中，导入运行时数据区的**方法区**中。
2.  当一个类首次被**主动加载**或**被动加载**时，类加载器会对此类执行类加载的流程 – **加载**、**连接**（**验证**、**准备**、**解析**）、**初始化**。
3.  如果类加载成功，**堆内存**中会产生一个新的`Class`对象，`Class`对象封装了类在**方法区**内的**数据结构**。

`Class`对象的创建过程描述：

![jvm_method_area_heap.png][]

## (二). 类加载的过程 ##

类加载的过程分为三个步骤(五个阶段) ：**加载** \-> **连接**（**验证**、**准备**、**解析**）-> **初始化**。

**加载**、**验证**、**准备**和**初始化**这四个阶段发生的顺序是**确定的**，而**解析阶段**可以在初始化阶段之后发生，也称为**动态绑定**或**晚期绑定**。

类加载的过程描述：  
![jvm_loader.png][]

### 1. 加载 ###

加载：查找并加载类的**二进制数据**的过程。

#### 加载的过程描述： ####

1.  通过类的**全限定名**定位`.class`文件，并获取其**二进制字节流**。
2.  把字节流所代表的**静态存储结构**转换为**方法区**的**运行时数据结构**。
3.  在`Java`**堆**中生成一个此类的`java.lang.Class`对象，作为方法区中这些数据的**访问入口**。

### 2. 连接 ###

连接：包括**验证**、**准备**、**解析**三步。

### a). 验证 ###

验证：确保被加载的类的**正确性**。验证是连接阶段的第一步，用于确保`Class`字节流中的信息是否符合虚拟机的要求。

#### 具体验证形式： ####

1.  **文件格式验证**：验证字节流是否符合`Class`文件格式的规范；例如：是否以`0xCAFEBABE`开头、主次版本号是否在当前虚拟机的处理范围之内、常量池中的常量是否有不被支持的类型。
2.  **元数据验证**：对字节码描述的信息进行语义分析（注意：对比`javac`编译阶段的语义分析），以保证其描述的信息符合Java语言规范的要求；例如：这个类是否有父类，除了`java.lang.Object`之外。
3.  **字节码验证**：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。
4.  **符号引用验证**：确保解析动作能正确执行。

### b). 准备 ###

准备：为类的**静态变量**分配内存，并将其初始化为**默认值**。准备过程通常分配一个结构用来存储类信息，这个结构中包含了类中定义的**成员变量**，**方法**和**接口信息**等。

#### 具体行为： ####

1.  这时候进行内存分配的仅包括**类变量**(`static`)，而不包括**实例变量**，**实例变量**会在对象**实例化**时随着对象一块分配在`Java`**堆**中。
2.  这里所设置的**初始值**通常情况下是数据类型**默认的零值**（如`0`、`0L`、`null`、`false`等），而不是被在`Java`代码中被**显式赋值**。

### c). 解析 ###

解析：把类中对**常量池**内的**符号引用**转换为**直接引用**。

解析动作主要针对**类或接口**、**字段**、**类方法**、**接口方法**、**方法类型**、**方法句柄**和**调用点限定符**等7类符号引用进行。

### 3. 初始化 ###

初始化：对**类静态变量**赋予正确的初始值 (注意和连接时的**解析过程**区分开)。

#### 初始化的目标 ####

1.  实现对声明**类静态变量**时指定的初始值的初始化；
2.  实现对使用**静态代码块**设置的初始值的初始化。

#### 初始化的步骤 ####

1.  如果此类没被**加载**、**连接**，则先**加载**、**连接**此类；
2.  如果此类的**直接父类**还未被初始化，则先**初始化**其直接父类；
3.  如果类中有**初始化语句**，则按照顺序依次执行初始化语句。

#### 初始化的时机 ####

1.  创建类的实例(`new`关键字)；
2.  `java.lang.reflect`包中的方法(如：`Class.forName(“xxx”)`)；
3.  对类的**静态变量**进行访问或赋值；
4.  访问调用类的**静态方法**；
5.  初始化一个类的**子类**，**父类**本身也会被初始化；
6.  作为程序的**启动入口**，包含`main`方法(如：`SpringBoot`入口类)。

## (三). 类的主动引用和被动引用 ##

### 主动引用 ###

主动引用：在类加载阶段，只执行**加载**、**连接**操作，不执行**初始化**操作。

#### 主动引用的几种形式 ####

#### 主动引用1 - main方法在初始类中 ####

代码示例：

public class OptimisticReference0 { 
        static {
            System.out.println(OptimisticReference0.class.getSimpleName() + " is referred!");
        }
    
        public static void main(String[] args) {
            System.out.println();
        }
    }

运行结果：

> OptimisticReference0 is referred!

#### 主动引用2 – 创建子类会触发父类的初始化 ####

代码示例：

public class OptimisticReference1 { 
        public static class Parent { 
            static {
                System.out.println(Parent.class.getSimpleName() + " is referred!");
            }
        }
    
        public static class Child extends Parent { 
            static {
                System.out.println(Child.class.getSimpleName() + " is referred!");
            }
        }
    
        public static void main(String[] args) {
            new Child();
        }
    }

运行结果：

> Parent is referred!  
> Child is referred!

#### 主动引用3 – 访问一个类静态变量 ####

代码示例：

public class OptimisticReference2 { 
        public static class Child { 
            protected static String name;
            static {
                System.out.println(Child.class.getSimpleName() + " is referred!");
                name = "Child";
            }
        }
    
        public static void main(String[] args) {
            System.out.println(Child.name);
        }
    }

运行结果：

> Child is referred!  
> Child

#### 主动引用4 – 对类的静态变量进行赋值 ####

代码示例：

public class OptimisticReference3 { 
        public static class Child { 
            protected static String name;
            static {
                System.out.println(Child.class.getSimpleName() + " is referred!");
            }
        }
    
        public static void main(String[] args) {
            Child.name = "Child";
        }
    }

运行结果：

> Child is referred!

#### 主动引用5 – 使用java.lang.reflect包提供的反射机制 ####

代码示例：

public class OptimisticReference4 { 
        public static void main(String[] args) throws ClassNotFoundException {
            Class.forName("org.ostenant.jdk8.learning.examples.reference.optimistic.Child");
        }
    }

运行结果：

> Child is referred!

### 被动引用 ###

被动引用： 在类加载阶段，会执行**加载**、**连接**和**初始化**操作。

被动引用的几种形式：  
1. 通过子类引用**父类**的的**静态字段**，不会导致**子类**初始化；  
2. 定义类的**数组引用**而**不赋值**，不会触发此类的初始化；  
3. 访问类定义的**常量**，不会触发此类的初始化。

#### 被动引用1 – 子类引用父类的的静态字段，不会导致子类初始化 ####

代码示例：

public class NegativeReference0 { 
        public static class Parent { 
            public static String name = "Parent";
            static {
                System.out.println(Parent.class.getSimpleName() + " is referred!");
            }
        }
    
        public static class Child extends Parent { 
            static {
                System.out.println(Child.class.getSimpleName() + " is referred!");
            }
        }
    
        public static void main(String[] args) {
            System.out.println(Child.name);
        }
    }

运行结果：

> Parent is referred!  
> Parent

#### 被动引用2 – 定义类的数组引用而不赋值，不会触发此类的初始化 ####

代码示例：

public class NegativeReference1 { 
        public static class Child { 
            static {
                System.out.println(Child.class.getSimpleName() + " is referred!");
            }
        }
    
        public static void main(String[] args) {
            Child[] childs = new Child[10];
        }
    }

运行结果：

> 无输出

#### 被动引用3 – 访问类定义的常量，不会触发此类的初始化 ####

示例代码：

public class NegativeReference2 { 
        public static class Child { 
            public static final String name = "Child";
            static {
                System.out.println(Child.class.getSimpleName() + " is referred!");
            }
        }
    
        public static void main(String[] args) {
            System.out.println(Child.name);
        }
    }

运行结果：

> Child

## (四). 三种类加载器 ##

类加载器：**类加载器**负责加载程序中的**类型**（类和接口），并赋予唯一的名字予以标识。

#### 类加载器的组织结构 ####

![class_loaders.png][]

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

1.  `Bootstrap Classloader` 是在`Java`虚拟机启动后初始化的。
2.  `Bootstrap Classloader` 负责加载 `ExtClassLoader`，并且将 `ExtClassLoader`的父加载器设置为 `Bootstrap Classloader`
3.  `Bootstrap Classloader` 加载完 `ExtClassLoader` 后，就会加载 `AppClassLoader`，并且将 `AppClassLoader` 的父加载器指定为 `ExtClassLoader`。

#### 类加载器的作用 ####

<table> 
 <thead> 
  <tr> 
   <th align="right">Class Loader</th> 
   <th align="left">实现方式</th> 
   <th align="left">具体实现类</th> 
   <th align="left">负责加载的目标</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="right">Bootstrap Loader</td> 
   <td align="left">C++</td> 
   <td align="left">由C++实现</td> 
   <td align="left"><code>%JAVA_HOME%/jre/lib/rt.jar</code>以及<code>-Xbootclasspath</code>参数指定的路径以及中的类库</td> 
  </tr> 
  <tr> 
   <td align="right">Extension ClassLoader</td> 
   <td align="left">Java</td> 
   <td align="left">sun.misc.Launcher$ExtClassLoader</td> 
   <td align="left"><code>%JAVA_HOME%/jre/lib/ext</code>路径下以及<code>java.ext.dirs</code>系统变量指定的路径中类库</td> 
  </tr> 
  <tr> 
   <td align="right">Application ClassLoader</td> 
   <td align="left">Java</td> 
   <td align="left">sun.misc.Launcher$AppClassLoader</td> 
   <td align="left"><code>Classpath</code>以及<code>-classpath</code>、<code>-cp</code>指定目录所指定的位置的类或者是<code>jar</code>文档，它也是<code>Java</code>程序默认的类加载器</td> 
  </tr> 
 </tbody> 
</table>

#### 类加载器的特点 ####

*  **层级结构**：Java里的类装载器被组织成了有父子关系的层级结构。Bootstrap类装载器是所有装载器的父亲。
 *  **代理模式**： 基于层级结构，类的代理可以在装载器之间进行代理。当装载器装载一个类时，首先会检查它在父装载器中是否进行了装载。如果上层装载器已经装载了这个类，这个类会被直接使用。反之，类装载器会请求装载这个类
 *  **可见性限制**：一个子装载器可以查找父装载器中的类，但是一个父装载器不能查找子装载器里的类。
 *  **不允许卸载**：类装载器可以装载一个类但是不可以卸载它，不过可以删除当前的类装载器，然后创建一个新的类装载器装载。

#### 类加载器的隔离问题 ####

每个**类装载器**都有一个自己的**命名空间**用来保存已装载的类。当一个类装载器装载一个类时，它会通过保存在命名空间里的**类全局限定名**(`Fully Qualified Class Name`) 进行搜索来检测这个类是否已经被加载了。

`JVM` 及 `Dalvik` 对类唯一的识别是 `ClassLoader id` \+ `PackageName` \+ `ClassName`，所以一个运行程序中是有可能存在两个**包名**和**类名**完全一致的类的。并且如果这两个**类**不是由一个 `ClassLoader` 加载，是无法将一个类的实例**强转**为另外一个类的，这就是 `ClassLoader` 隔离性。

为了解决类加载器的**隔离问题**，`JVM`引入了**双亲委托机制**。

## (五). 双亲委托机制 ##

核心思想：其一，**自底向上**检查类是否**已加载**；其二，**自顶向下**尝试**加载类**。

#### 具体加载过程 ####

1.  当`AppClassLoader`加载一个`class`时，它首先不会自己去尝试加载这个类，而是把类加载请求**委派**给**父类加载器**`ExtClassLoader`去完成。
2.  当`ExtClassLoader`加载一个`class`时，它首先也不会自己去尝试加载这个类，而是把类加载请求**委派**给`BootStrapClassLoader`去完成。
3.  如果`BootStrapClassLoader`加载失败（例如在`%JAVA_HOME%/jre/lib`里未查找到该`class`），会使用`ExtClassLoader`来尝试加载；
4.  如果`ExtClassLoader`也加载失败，则会使用`AppClassLoader`来加载，如果`AppClassLoader`也加载失败，则会报出异常`ClassNotFoundException`。

#### 源码分析 ####

ClassLoader.class

1.  **loadClass()**：通过指定类的**全限定名称**，由类加载器**检测**、**装载**、**创建**并返回该类的`java.lang.Class`对象。  
    ![ClassLoader_loadClass.png][]  
    
    
    > `ClassLoader`通过`loadClass()`方法实现了**双亲委托机制**，用于类的**动态加载**。

`loadClass()`本身是一个 **递归向上调用**的过程。

*  **自底向上**检查类是否**已加载**
    
    1.  先通过`findLoadedClass()`方法从最**底端类加载器**开始检查类是否已经加载。
    2.  如果已经加载，则根据`resolve`参数决定是否要执行**连接**过程，并返回`Class`对象。
    3.  如果没有加载，则通过`parent.loadClass()`委托其父类加载器执行相同的检查操作(默认不做连接处理)。
    4.  直到**顶级类加载器**，即`parent`为空时，由`findBootstrapClassOrNull()`方法尝试到`Bootstrap ClassLoader`中检查目标类。
 *  **自顶向下**尝试**加载类**
    
    1.  如果仍然没有找到目标类，则从`Bootstrap ClassLoader`开始，通过`findClass()`方法尝试到对应的**类目录**下去加载目标类。
    2.  如果加载成功，则根据`resolve`参数决定是否要执行**连接**过程，并返回`Class`对象。
    3.  如果加载失败，则由其**子类加载器**尝试加载，直到最**底端类加载器**也加载失败，最终抛出`ClassNotFoundException`。
    4.  **findLoadedClass()**  
        ![ClasslOADER_findLoadedClass.png][]
        
        > 查找当前**类加载器的缓存中**是否已经加载目标类。`findLoadedClass()`实际调用了底层的`native`方法`findLoadedClass0()`。
    5.  **findBootstrapClassOrNull()**  
        ![ClassLoader_fidnBootstrapOrNull.png][]
        
        > 查找最顶端`Bootstrap`**类加载器**的是否已经加载目标类。同样，`findBootstrapClassOrNull()`实际调用了底层的`native`方法`findBootstrapClass()`。
    6.  **findClass()**  
        ![ClassLoader_findClass.png][]
        
        > `ClassLoader`是`java.lang`包下的**抽象类**，也是所有类加载器(除了`Bootstrap`)的基类，`findClass()`是`ClassLoader`对子类提供的加载目标类的抽象方法。
        > 
        > **注意**：`Bootstrap ClassLoader`并不属于`JVM`的层次，它不遵守`ClassLoader`的加载规则，`Bootstrap classLoader`并没有子类。
    7.  **defineClass()**  
        ![ClassLoader_defineClass.png][]
        
        > `defineClass()`是`ClassLoader`向子类提供的方法，它可以将.`class`文件的**二进制数据**转换为合法的`java.lang.Class`对象。

## (六). 类的动态加载 ##

#### 类的几种加载方式 ####

*  通过**命令行**启动时由`JVM`初始化加载；
 *  通过`Class.forName()`方法动态加载；
 *  通过`ClassLoader.loadClass()`方法动态加载。

#### Class.forName()和ClassLoader.loadClass() ####

*  **Class.forName()**：把类的`.class`文件加载到`JVM`中，对类进行解释的同时执行类中的`static`**静态代码块**；
 *  **ClassLoader.loadClass()**：只是把.class文件加载到`JVM`中，不会执行`static`**代码块**中的内容，只有在`newInstance`才会去执行。

## (七). 对象的初始化 ##

#### 对象的初始化顺序 ####

静态变量/静态代码块 -> 普通代码块 -> 构造函数 1. 父类\*\*静态变量\*\*和\*\*静态代码块\*\*（先声明的先执行）； 2. 子类\*\*静态变量\*\*和\*\*静态代码块\*\*（先声明的先执行）； 3. 父类\*\*普通成员变量\*\*和\*\*普通代码块\*\*（先声明的先执行）； 4. 父类的\*\*构造函数\*\*； 5. 子类\*\*普通成员变量\*\*和\*\*普通代码块\*\*（先声明的先执行）； 6. 子类的\*\*构造函数\*\*。

#### 对象的初始化示例 ####

Parent.java !\[\](http://ols3fdyll.bkt.clouddn.com/image/png/ClassLoader\_LoadSequence\_Parent.png) Children.java !\[\](http://ols3fdyll.bkt.clouddn.com/image/png/ClassLoader\_LoadSequence\_Children.png) Tester.java !\[\](http://ols3fdyll.bkt.clouddn.com/image/png/ClassLoader\_LoadSequence\_Tester.png) 测试结果： !\[\](http://ols3fdyll.bkt.clouddn.com/image/png/ClassLoader\_LoadSequence\_Tester.\_Result.png) 测试结果表明：\`JVM\`在创建对象时，遵守以上对象的初始化顺序。

## (八). 自定义类加载器 ##

#### 编写自己的类加载器 ####

在源码分析阶段，我们已经解读了如何实现\*\*自定义类加载器\*\*，现在我们开始\*\*怼\*\*自己的类加载器。

> Step 1：定义待加载的目标类`Parent.java`和`Children.java`。

Parent.java

package org.ostenant.jdk8.learning.examples.classloader.custom;
    
    public class Parent { 
        protected static String CLASS_NAME;
        protected static String CLASS_LOADER_NAME;
        protected String instanceID;
    
        // 1.先执行静态变量和静态代码块（只在类加载期间执行一次）
        static {
            CLASS_NAME = Parent.class.getName();
            CLASS_LOADER_NAME = Parent.class.getClassLoader().toString();
            System.out.println("Step a: " + CLASS_NAME + " is loaded by " + CLASS_LOADER_NAME);
        }
    
        // 2.然后执行变量和普通代码块（每次创建实例都会执行）
        {
            instanceID = this.toString();
            System.out.println("Step c: Parent instance is created: " + CLASS_LOADER_NAME + " -> " + instanceID);
        }
    
        // 3.然后执行构造方法
        public Parent() {
            System.out.println("Step d: Parent instance：" + instanceID + ", constructor is invoked");
        }
    
        public void say() {
            System.out.println("My first class loader...");
        }
    }

Children.java

package org.ostenant.jdk8.learning.examples.classloader.custom;
    
    public class Children extends Parent { 
        static {
            CLASS_NAME = Children.class.getName();
            CLASS_LOADER_NAME = Children.class.getClassLoader().toString();
            System.out.println("Step b: " + CLASS_NAME + " is loaded by " + CLASS_LOADER_NAME);
        }
    
        {
            instanceID = this.toString();
            System.out.println("Step e: Children instance is created: " + CLASS_LOADER_NAME + " -> " + instanceID);
        }
    
        public Children() {
            System.out.println("Step f: Children instance：" + instanceID + ", constructor is invoked");
        }
    
        public void say() {
            System.out.println("My first class loader...");
        }
    }

> Step 2：实现自定义类加载器`CustomClassLoader`

CustomClassLoader.java

public class CustomClassLoader extends ClassLoader { 
        private String classPath;
    
        public CustomClassLoader(String classPath) {
            this.classPath = classPath;
        }
    
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            Class<?> c = findLoadedClass(name); // 可省略
            if (c == null) {
                byte[] data = loadClassData(name);
                if (data == null) {
                    throw new ClassNotFoundException();
                }
                return defineClass(name, data, 0, data.length);
            }
            return null;
        }
    
        protected byte[] loadClassData(String name) {
            try {
                // package -> file folder
                name = name.replace(".", "//");
                FileInputStream fis = new FileInputStream(new File(classPath + "//" + name + ".class"));
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                int len = -1;
                byte[] b = new byte[2048];
                while ((len = fis.read(b)) != -1) {
                    baos.write(b, 0, len);
                }
                fis.close();
                return baos.toByteArray();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    }

> Step 3：测试类加载器的加载过程

CustomerClassLoaderTester.java

1.  测试程序启动时，逐一**拷贝**并**加载**待加载的**目标类源文件**。

private static final String CHILDREN_SOURCE_CODE_NAME = SOURCE_CODE_LOCATION + "Children.java";
        private static final String PARENT_SOURCE_CODE_NAME = SOURCE_CODE_LOCATION + "Parent.java";
        private static final List<String> SOURCE_CODE = Arrays.asList(CHILDREN_SOURCE_CODE_NAME, PARENT_SOURCE_CODE_NAME);
    
        static {
            SOURCE_CODE.stream().map(path -> new File(path))
                // 路径转文件对象
                .filter(f -> !f.isDirectory())
                // 文件遍历
                .forEach(f -> {
                // 拷贝后源代码
                File targetFile = copySourceFile(f);
                // 编译源代码
                compileSourceFile(targetFile);
            });
        }

1.  拷贝单一源文件到自定义类加载器的**类加载目录**。

protected static File copySourceFile(File f) {
            BufferedReader reader = null;
            BufferedWriter writer = null;
            try {
                reader = new BufferedReader(new FileReader(f));
                // package ...;
                String firstLine = reader.readLine();
    
                StringTokenizer tokenizer = new StringTokenizer(firstLine, " ");
                String packageName = "";
                while (tokenizer.hasMoreElements()) {
                    String e = tokenizer.nextToken();
                    if (e.contains("package")) {
                        continue;
                    } else {
                        packageName = e.trim().substring(0, e.trim().length() - 1);
                    }
                }
    
                // package -> path
                String packagePath = packageName.replace(".", "//");
                // java file path
                String targetFileLocation = TARGET_CODE_LOCALTION + "//" + packagePath + "//";
    
                String sourceFilePath = f.getPath();
                String fileName = sourceFilePath.substring(sourceFilePath.lastIndexOf("\\") + 1);
    
                File targetFile = new File(targetFileLocation, fileName);
                File targetFileLocationDir = new File(targetFileLocation);
                if (!targetFileLocationDir.exists()) {
                    targetFileLocationDir.mkdirs();
                }
                // writer
                writer = new BufferedWriter(new FileWriter(targetFile));
                // 写入第一行
                writer.write(firstLine);
                writer.newLine();
                writer.newLine();
    
                String input = "";
                while ((input = reader.readLine()) != null) {
                writer.write(input);
                    writer.newLine();
                }
    
                return targetFile;
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    reader.close();
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return null;
        }

1.  对拷贝后的`.java`源文件执行手动编译，在同级目录下生成`.class`文件。

protected static void compileSourceFile(File f) {
            try {
                JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
                StandardJavaFileManager standardFileManager = javaCompiler.getStandardFileManager(null, null, null);
                Iterable<? extends JavaFileObject> javaFileObjects = standardFileManager.getJavaFileObjects(f);
    
                // 执行编译任务
                CompilationTask task = javaCompiler.getTask(null, standardFileManager, null, null, null, javaFileObjects);
                task.call();
                standardFileManager.close();
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

1.  通过**自定义类加载器**加载`Children`的`java.lang.Class<?>`对象，然后用反射机制创建`Children`的实例对象。

@Test
        public void test() throws Exception {
            // 创建自定义类加载器
            CustomClassLoader classLoader = new CustomClassLoader(TARGET_CODE_LOCALTION); // E://myclassloader//classpath
            // 动态加载class文件到内存中（无连接）
            Class<?> c = classLoader.loadClass("org.ostenant.jdk8.learning.examples.classloader.custom.Children");
            // 通过反射拿到所有的方法
            Method[] declaredMethods = c.getDeclaredMethods();
            for (Method method : declaredMethods) {
                if ("say".equals(method.getName())) {
                    // 通过反射拿到children对象
                    Object children = c.newInstance();
                    // 调用children的say()方法
                    method.invoke(children);
                    break;
                }
            }
        }

#### 测试编写的类加载器 ####

#### (一). 测试场景一 ####

1.  **保留**`static`代码块，把目标类`Children.java`和`Parent.java`**拷贝**到类加载的目录，然后进行手动**编译**。
2.  **保留**测试项目目录中的目标类`Children.java`和`Parent.java`。  
    ![ClassLoader_With_Parent_Children_In_Project.png][]

测试结果输出：  
![Class_Loader_Situation_1_Result.png][]

测试结果分析：

> 我们成功创建了`Children`对象，并通过反射调用了它的`say()`方法。  
> 然而查看控制台日志，可以发现类加载使用的仍然是`AppClassLoader`，`CustomClassLoader`并没有生效。

查看`CustomClassLoader`的类加载目录：  
![ClassLoader_Target_Folder_Class.png][]

> 类目录下有我们**拷贝**并**编译**的`Parent`和`Chidren`文件。

分析原因：

> 由于项目空间中的`Parent.java`和`Children.java`，在拷贝后并没有移除。导致`AppClassLoader`优先在其`Classpath`下面**找到**并成功**加载**了目标类。

#### (二). 测试场景二 ####

1.  **注释掉**`static`代码块（类目录下有已编译的目标类`.class`文件）。
2.  **移除**测试项目目录中的目标类`Children.java`和`Parent.java`。  
    ![ClassLoader_Without_Parent_Children_In_Project.png][]

测试结果输出：  
![ClassLoader_Situation_2_Console.png][]  
测试结果分析：

> 我们成功通过**自定义类加载器**加载了目标类。创建了`Children`对象，并通过反射调用了它的`say()`方法。

至此，我们自己的一个简单的类加载器就完成了！

# 参考书籍 #

周志明，深入理解Java虚拟机：JVM高级特性与最佳实践，机械工业出版社

--------------------

欢迎关注技术公众号： 零壹技术栈

![零壹技术栈][1240]

本帐号将持续分享后端技术干货，包括虚拟机基础，多线程编程，高性能框架，异步、缓存和消息中间件，分布式和微服务，架构学习和进阶等学习资料和文章。

[JVM_E7_B1_BB_E5_8A_A0_E8_BD_BD_E6_9C_BA_E5_88_B6.png]: http://ols3fdyll.bkt.clouddn.com/image/png/JVM%E7%B1%BB%E5%8A%A0%E8%BD%BD%E6%9C%BA%E5%88%B6.png
[jvm_method_area_heap.png]: http://ols3fdyll.bkt.clouddn.com/image/png/jvm_method_area_heap.png
[jvm_loader.png]: http://ols3fdyll.bkt.clouddn.com/image/png/jvm_loader.png
[class_loaders.png]: http://ols3fdyll.bkt.clouddn.com/class_loaders.png
[ClassLoader_loadClass.png]: http://ols3fdyll.bkt.clouddn.com/image/png/ClassLoader_loadClass.png
[ClasslOADER_findLoadedClass.png]: http://ols3fdyll.bkt.clouddn.com/image/png/ClasslOADER_findLoadedClass.png
[ClassLoader_fidnBootstrapOrNull.png]: http://ols3fdyll.bkt.clouddn.com/image/png/ClassLoader_fidnBootstrapOrNull.png
[ClassLoader_findClass.png]: http://ols3fdyll.bkt.clouddn.com/image/png/ClassLoader_findClass.png
[ClassLoader_defineClass.png]: http://ols3fdyll.bkt.clouddn.com/image/png/ClassLoader_defineClass.png
[ClassLoader_With_Parent_Children_In_Project.png]: http://ols3fdyll.bkt.clouddn.com/image/png/ClassLoader_With_Parent_Children_In_Project.png
[Class_Loader_Situation_1_Result.png]: http://ols3fdyll.bkt.clouddn.com/image/png/Class_Loader_Situation_1_Result.png
[ClassLoader_Target_Folder_Class.png]: http://ols3fdyll.bkt.clouddn.com/image/png/ClassLoader_Target_Folder_Class.png
[ClassLoader_Without_Parent_Children_In_Project.png]: http://ols3fdyll.bkt.clouddn.com/image/png/ClassLoader_Without_Parent_Children_In_Project.png
[ClassLoader_Situation_2_Console.png]: http://ols3fdyll.bkt.clouddn.com/image/png/ClassLoader_Situation_2_Console.png
[1240]: /images/20220515/d0522169b29c4649a7bd276f56a2b173.png