从零造就JVM大牛（一）

引言

从事java的小伙伴大家好，如果你是一名从事java行业的程序员，无论你是小白还是工作多年的老司机，我相信这篇文章一定会给你带来

不同程度的收货不敢说你看完我的文章从此精通jvm打遍天下无对手，但我能保证的是看完我的文章并且实践操作加以理解，至少在jvm

的这个领域碾压百分之80以上的程序员。废话不多说我们进入正题。（此文连载，请持续关注！！！）

一：类加载

我相信很多从事java的小伙伴儿在网上或者视频上也看了很多关于jvm的文章和讲解，但总觉得缺少点儿什么，那么今天我来告诉你为什么

会有这种感觉，因为很多人或者说很多文章讲的jvm都没有从最底层，没有从人的习惯性思维上去剖析。从今天开始，我就要把jvm那点儿

事儿给小伙伴儿们说清楚。保证你会见到jvm领域的另一番美妙的天地。

废话不多说直接进入正题。讲类加载器之前，咱们先从类加载开始说起，那么java底层是如何加载一个类的呢，他的顺序是怎么样的呢？下面

我会细致的手把手带你分析。

在java代码中,类型的加载,连接，初始化过程都是在程序运行期间完成的.

类型加载：这里的类型指的的是什么呢？

答：类型就是指的我们Java源代码通过编译后的class文件

类型的来源有哪些？类型的来源我总结了以下7点内容

答：

1：本地磁盘

2：网络下载.class文件

3：war，jar下加载.class文件

4：从专门的数据库中读取.class文件(少见)

5：将java源文件动态编译成class文件

6：典型的就是动态代理，通过运行期生成class文件

7：我们的jsp会被转换成servlet，而我们的serlvet是一个java文件，会被编译成class文件

那么我们的是通过什么进行加载的呢？是如何被加载到jvm中的呢？

答：通过我们的类加载器(classLoader)进行加载

首先我们来了解以下类加载器的种类？系统级别的类加载器如下

1：启动类加载器（Bootstrap Classloader）

2：扩展类加载器(Extention ClassLoader)

3：应用类加载器

非系统级别类加载器如下：

1：自定义类加载器

接下来我们一个一个类加载剖析，好好的讲讲他们的前世今生，以及作用，让你彻底的了解类加载器到底是什么。

一：启动类加载器（Bootstrap Classloader）重点剖析

加载的职责：负责加载JAVA_HOME/jre/lib/rt.jar。该加载器是有C++实现，不是ClassLoader类的子类。

接下来我们会以代码穿插的方式来讲清楚类加载器到底是什么。很多人只是用嘴说，这样当时听懂了，然而并不能

真正的体会到类加载器以及类加载的精髓。只有用示例去验证你的说法，这才是正确的学习姿势。废话不多说开搞。

首先创建一个java工程 jvm-classloader jdk版本采用1.8.0_144 包名为src/com.test 创建类 MainClass01，结构如下图：

首先我们通过代码的形式来看看，我们的启动类加载器到底加载了哪些包

package com.test;

import java.util.Arrays;

import java.util.List;

/**

 * jvm 类加载器 第一章

 * @author 奇客时间-时光

 * 打印启动类加载器加载的路径

 */

public class MainClass01 {

    public static void main(String[] args) {

        String bootStrapLoadingPath = System.getProperty("sun.boot.class.path");

        List<String> bootLoadingPathList = Arrays.asList(bootStrapLoadingPath.split(";"));

        for(String bootPath:bootLoadingPathList) {

            System.out.println("启动类加载器加载的目录:{}"+bootPath);

        }

    }

}

"C:\Program Files\Java\jdk1.8.0_144\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=60329:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_144\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\rt.jar;I:\jvm\out\production\jvm-classloader" com.test.MainClass01

启动类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\resources.jar

启动类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\rt.jar

启动类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\sunrsasign.jar

启动类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\jsse.jar

启动类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\jce.jar

启动类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\charsets.jar

启动类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\jfr.jar

启动类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\classes

Process finished with exit code 0

通过以上运行代码可知，启动类加载器加载如下的这些jar包。包含了大家常说的rt.jar。那么现在有个问题，从运行结果上我们看启动类加载加载了C:\Program Files\Java\jdk1.8.0_144\jre\classes这个目录下的类。那么我们自己写一个类，编译成Class文件以后丢到这个目录下它会被加载嘛？我们不妨来试一下。我们在com.test包下面创建一个Cat类。然后找到编译好的Cat.class文件，扔到C:\Program Files\Java\jdk1.8.0_144\jre\classes目录下。

如图可知，我们jre目录并没有classes目录，所以我们手动创建一个，并且把Cat.class文件扔进去。然后在测试类中获取一下Cat.classLoader是什么，由此就可以知道Cat是不是被启动类加载器加载了。

由上面的运行结果可知，我们的Cat类确实被启动类加载器给加载了。为什么是null？当一个类被启动类加载器加载以后，那么他的getClassLoader返回的结果就是null，这也是启动类加载器和其他类加载器不一样的地方。

补充说明：Bootstrap Classloader加载器是由C++去加载的，然后Bootstrap Classloader加载rt等jar包，Bootstrap Classloader加载器也加载了系统类加载器和扩展类类加载器他们都位于sun.boot.class.path这个路径。

二：扩展类加载器（Extention ClassLoader）重点剖析

加载的职责：加载java平台扩展的jar包，\lib\ext，可以通过-Djava.ext.dirs指定加载的路径

该加载器是有java代码编写的，并且是ClassLoader的子类,位于sun.misc.Launcher$ExtClassLoader 是我们launch类的一个内部类

同样的我们在MainClass01中测试一下

package com.test;

import java.util.Arrays;

import java.util.List;

/**

 * jvm 类加载器 第一章

 * @author 奇客时间-时光

 * 打印启动类加载器加载的目录

 * 打印扩展类加载器加载的目录

 */

public class MainClass01 {

    public static void main(String[] args) {

        String extLoadingPath = System.getProperty("java.ext.dirs");

        List<String> list = Arrays.asList(extLoadingPath.split(";"));

        for(String extpath:list) {

            System.out.println("扩展类加载器加载的目录:{}"+extpath);

        }

    }

}

"C:\Program Files\Java\jdk1.8.0_144\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=59761:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_144\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\rt.jar;I:\jvm\out\production\jvm-classloader" com.test.MainClass01

扩展类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext

扩展类加载器加载的目录:{}C:\WINDOWS\Sun\Java\lib\ext

Process finished with exit code 0

三：应用类加载器（APP ClassLoader）重点剖析

加载的职责:负责加载我们工程目录下classpath下的文件下.class以及jar包

该加载器也是由Java代码编写的也是我们ClassLoader的一个子类,sun.misc.Launcher$AppClassLoader 是我们的launcher的内部类

String appLoadingPath = System.getProperty("java.class.path");

同样的，我们在MainClass01中运行如下代码：

package com.test;

import java.util.Arrays;

import java.util.List;

/**

 * jvm 类加载器 第一章

 * @author 奇客时间-时光

 * 打印启动类加载器加载的目录

 * 打印扩展类加载器加载的目录

 * 打印应用类加载器加载的目录

 */

public class MainClass01 {

    public static void main(String[] args) {

        String appLoadingPath = System.getProperty("java.class.path");

        List<String> appLoadingPathList = Arrays.asList(appLoadingPath.split(";"));

        for(String appPath:appLoadingPathList) {

            System.out.println("应用类加载器加载的目录:{}"+appPath);

        }

    }

}

"C:\Program Files\Java\jdk1.8.0_144\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=52479:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_144\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\rt.jar;I:\jvm\out\production\jvm-classloader" com.test.MainClass01

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\charsets.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\deploy.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\access-bridge-64.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\cldrdata.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\dnsns.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\jaccess.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\jfxrt.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\localedata.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\nashorn.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunec.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunjce_provider.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunmscapi.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\sunpkcs11.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\zipfs.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\javaws.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\jce.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\jfr.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\jfxswt.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\jsse.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\management-agent.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\plugin.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\resources.jar

应用类加载器加载的目录:{}C:\Program Files\Java\jdk1.8.0_144\jre\lib\rt.jar

应用类加载器加载的目录:{}I:\jvm\out\production\jvm-classloader

应用类加载器加载的目录:{}C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar

Process finished with exit code 0

四：我们自定义的类加载器

由此可知，三种类加载所加载对应的目录已经介绍完毕，后面还会对这三种类加载器进行深入的解析。下面我们再看看自定义类加载器。为什么需要自定义类加载器呢？因为有些场景下jdk给我们提供的三种类加载器没有办法实现我们的个性化需求。关于为什么，这个我后面会详细阐述。我们首先看看自定义类加载器以及源码。

如何写自定义类加载器呢？首先我们看看jdk 提供的java原版 doc文档是如何描述的，这里要说一下，无论各位小伙伴以后学什么技术，第一手资料很重要。因为是最权威的，也没有经过任何加工的，也是最准确的。所以我们直接看源码中的doc文档即可。

那么我们要写自己的类加载器，对于小白来说肯定是不清楚如何下手的。这个时候，我们就要想，自定义类加载肯定是和类加载器有关系，不放我们看看java有没有提供关于类加载器相关的类。于是我们可以通过IDEA的编辑器进行搜索一下，类加载器顾名思义 ClassLoader先搜索一下。结果还真有。说明这是一个跟类加载器有关的类，我们直接阅读他的java doc。

我把之前编辑好的中文注释贴在下面。大家可以阅读，不过这里还是建议学习jdk源码的小伙伴还是自己阅读比较好，这样记得也比较深刻。

4.1：ClassLoader抽象类文档解读

/**

* A class loader is an object that is responsible for loading classes(类加载器是一个对象,作用就是用来加载器类的). The

* class ClassLoader is an abstract class(本类是一个抽象的类). Given the binary name of a class

(给定一个类的二进制名字,比如java.lang.String就是String类的二进制名字)

, a class loader should attempt to

* locate or generate data that constitutes a definition for the class(那么类加载器尝试去定位(已经存在我们的磁盘文件中)

或者生成(为啥有生成,存在动态代理)构成class的定义数据).

A typical strategy is to transform the name into a file name and then read a

* "class file" of that name from a file system.(通常的策略就是把我们的类的二进制名称转换为我们的文件名称

比如java.lang.String 转换为java/lang/String)

那么就会根据这个文件名称去文件系统找到该class文件。

*

* <p> Every {@link Class <tt>Class</tt>} object contains a {@link

* Class#getClassLoader() reference} to the <tt>ClassLoader</tt> that defined

* it. (每一个通过类加载器加载的class文件后会返回一个Class对象,该Class对象会包含一个加载他的ClassLoader的对象引用)

*

* <p> <tt>Class</tt> objects for array classes are not created by class

* loaders, but are created automatically as required by the Java runtime.

我们的数组对象的Class对象不是由我们的类加载器创建的，而是由我们的jvm根据需要在运行时间创建出来的.

* The class loader for an array class, as returned by {@link

* Class#getClassLoader()} is the same as the class loader for its element

* type;(我们获取到了数组类型的CLass对象，通过该Class对象调用getClassLoader()返回的是跟我们数组元素中的类加载器是一样的)

if the element type is a primitive type, then the array class has no

* class loader.(如果我们原生的数组 那么该数组的Class没有类加载器)

* <p> Applications implement subclasses of <tt>ClassLoader</tt> in order to

* extend the manner in which the Java virtual machine dynamically loads

* classes.(我们通过实现ClassLoader,可以动态来扩展我们类加载的方式)

* <p> Class loaders may typically be used by security managers to indicate

* security domains.

* <p> The <tt>ClassLoader</tt> class uses a delegation model to search for

* classes and resources.(ClassLoader使用双亲委派模型来寻找类和资源) Each instance of <tt>ClassLoader</tt> has an

* associated parent class loader(classloader的每一个实例都会有一个parent的classLoader). When requested to find a class or

* resource, a <tt>ClassLoader</tt> instance will delegate the search for the

* class or resource to its parent class loader before attempting to find the

* class or resource itself(当我们发起类加载的请求,那么类加载器自己去寻找资源之前委托给父类). The virtual machine's built-in class loader,

* called the "bootstrap class loader", (虚拟机内嵌的classLoader是叫做启动类加载器)does not itself have a parent but may

* serve as the parent of a <tt>ClassLoader</tt> instance.(启动类加载器是没有双亲的，但是他可以作为其他类加载器的双亲)

* <p> Class loaders that support concurrent loading of classes are known as

* <em>parallel capable</em> class loaders(若一个类加载器支持并行加载的话，那么这个类加载器就叫做并行类加载器) and are required to register

* themselves at their class initialization time by invoking the

* {@link

* #registerAsParallelCapable <tt>ClassLoader.registerAsParallelCapable</tt>}

* method.(若一个类加载器想要成为一个并行类加载器的话，那么在该类加载器初始化的时候要求去调用ClassLoader.registerAsParallelCapable方法)

Note that the <tt>ClassLoader</tt> class is registered as parallel

* capable by default(默认情况下当前的这个类ClassLoader这个抽象类模式是并行加载器器). However, its subclasses still need to register themselves

* if they are parallel capable.(然而我们的子加载器需要成为并行的内加载器，需要注册自己为并行的类加载器) <br>

* In environments in which the delegation model is not strictly

* hierarchical(若我们的类加载器不是属于双亲委派的模型情况下), class loaders need to be parallel capable(类加载器需要注册为并行的加载器), otherwise class

* loading can lead to deadlocks because the loader lock is held for the

* duration of the class loading process (see {@link #loadClass

* <tt>loadClass</tt>} methods).(不然在内加载的阶段会导致死锁)

* <p> Normally, the Java virtual machine loads classes from the local file

* system in a platform-dependent manner(通常情况下 jvm从本地磁盘下去加载类). For example, on UNIX systems, the

* virtual machine loads classes from the directory defined by the

* <tt>CLASSPATH</tt> environment variable.(在unix系统中，虚拟机从classpath下加载类)

* <p> However, some classes may not originate from a file(然而，有些class文件不是存在我们的磁盘文件中); they may originate

* from other sources, such as the network(比如从网络上), or they could be constructed by an

* application(动态代理生产的). The method {@link #defineClass(String, byte[], int, int)

* <tt>defineClass</tt>} converts an array of bytes into an instance of class

* <tt>Class</tt>. (我们的defineClass方法会把字节数组转为我们一个class的实例)Instances of this newly defined class can be created using

* {@link Class#newInstance <tt>Class.newInstance</tt>}.这个实例可以通过我们的newInstance来调用

全盘委托模型:由我们classloader加载出来的class那么该类中的方法或构造函数可能引用其他类，jvm会调用同一个类加载器去加载被应用的类

* <p> The methods and constructors of objects created by a class loader may

* reference other classes(). To determine the class(es) referred to, the Java

* virtual machine invokes the {@link #loadClass <tt>loadClass</tt>} method of

* the class loader that originally created the class.

* <p> For example, an application could create a network class loader to

* download class files from a server. Sample code might look like:

* <blockquote><pre>

* ClassLoader loader&nbsp;= new NetworkClassLoader(host,&nbsp;port);

* Object main&nbsp;= loader.loadClass("Main", true).newInstance();

* &nbsp;.&nbsp;.&nbsp;.

* </pre></blockquote>

我们自定义的class laoder 需要重写我们的ClassLoader类的findClass 和我们的loadClassData方法

* <p> The network class loader subclass must define the methods {@link

* #findClass <tt>findClass</tt>} and <tt>loadClassData</tt> to load a class

* from the network. Once it has downloaded the bytes that make up the class,

* it should use the method {@link #defineClass <tt>defineClass</tt>} to

* create a class instance. A sample implementation is:

* <blockquote><pre>

* class NetworkClassLoader extends ClassLoader {

* String host;

* int port;

* public Class findClass(String name) {

* byte[] b = loadClassData(name);

* return defineClass(name, b, 0, b.length);

* }

* private byte[] loadClassData(String name) {

* // load the class data from the connection

* &nbsp;.&nbsp;.&nbsp;.

* }

* }

* </pre></blockquote>

* <h3> <a name="name">Binary names</a> </h3>

* <p> Any class name provided as a {@link String} parameter to methods in

* <tt>ClassLoader</tt> must be a binary name as defined by

* <cite>The Java&trade; Language Specification</cite>.

* <p> Examples of valid class names include:

* <blockquote><pre>

* "java.lang.String" 表示我们的String类的二进制名称

* "javax.swing.JSpinner$DefaultEditor" 表示JSpinner的内部类DefaultEditor的二进制名称

* "java.security.KeyStore$Builder$FileBuilder$1" 表示java.security.KeyStore类的内部类Builder类的内部类的FileBuilder的第一个内部类

* "java.net.URLClassLoader$3$1" 表示java.net.URLClassLoader类中第三个内部类中的第一个内部类

* </pre></blockquote>

* @see #resolveClass(Class)

* @since 1.0

*/

public abstract class ClassLoader {}

通过上面文档的描述我们可以实现ClassLoader这个类就可以动态来扩展我们类加载的方式。从上面的文档中也可以看出，加载一个class文件需要用到loadClass方法，并且还要重写ClassLoader类的findClass 和我们的loadClassData方法

接下来对上述的几个重要的方法的java doc进行翻译

4.2：我们的ClassLoader类加载器重要方法详解

loadClass方法详解

/**

* Loads the class with the specified <a href="#name">binary name</a>. (根据二进制名称进行加载) The

* default implementation of this method searches for classes in the(下面是调用方法的顺序)

* following order:

* <ol>

* <li><p> Invoke {@link #findLoadedClass(String)} to check if the class

* has already been loaded. </p></li> 调用findloaderClass检查类是否被加载过

* <li><p> Invoke the {@link #loadClass(String) <tt>loadClass</tt>} method

* on the parent class loader(首先会调用父类的loaderClass来加载). If the parent is <tt>null</tt> the class

* loader built-in to the virtual machine is used(若发现父类是null,那就说明已经到了顶层的启动类加载器),

instead. </p></li>

* <li><p> Invoke the {@link #findClass(String)} method to find the

* class. </p></li> 接下来就调用我们的findClass方法来查找class

* </ol>

* <p> If the class was found using the above steps(若通过上述步骤找到了class文件), and the

* <tt>resolve</tt> flag is true(那么就设置resolve为true), this method will then invoke the {@link

* #resolveClass(Class)} method on the resulting <tt>Class</tt> object.(解析来那么就通过调用resolverClass

返回对象)

* <p> Subclasses of <tt>ClassLoader</tt> are encouraged to override {@link

* #findClass(String)}, rather than this method. </p>

强烈的要求我们子类实现ClassLoader 那么我们必须要从写findClass方法

* <p> Unless overridden, this method synchronizes on the result of

* {@link #getClassLoadingLock <tt>getClassLoadingLock</tt>} method

* during the entire class loading process.

* @param name

* The <a href="#name">binary name</a> of the class

* @param resolve

* If <tt>true</tt> then resolve the class

* @return The resulting <tt>Class</tt> object

* @throws ClassNotFoundException

* If the class could not be found

*/

protected Class<?> loadClass(String name, boolean resolve)

throws ClassNotFoundException

{

synchronized (getClassLoadingLock(name)) {

//检查根据二进制名称是否被加载过

Class<?> c = findLoadedClass(name);

//没有加载过

if (c == null) {

long t0 = System.nanoTime();

try {

// 判断有没有父类,有父类 调用父类的loadClass

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

// to find the class.

long t1 = System.nanoTime();

//调用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) {

//解析我们的class进行连接 等操作

resolveClass(c);

}

return c;

}

}

上面这段java doc文档中有几个重要的点需要注意一下

1：根据二进制名称进行加载

2：调用findloaderClass检查类是否被加载过

3：首先会调用父类的loaderClass来加载

4：若发现父类是null,那就说明已经到了顶层的启动类加载器

5：接下来就调用我们的findClass方法来查找class

这几部是类加载器加载类的加载过程，比较重要的过程。希望各位小伙伴儿一定要结合源码牢记。

上述又提到了另一个方法

findClass()方法

/**

* Finds the class with the specified <a href="#name">binary name</a>.通过给定的二进制名称查找出class文件

* This method should be overridden by class loader implementations(这个方法应该被遵循双亲委托模型的子类重写) that

* follow the delegation model for loading classes(), and will be invoked by

* the {@link #loadClass <tt>loadClass</tt>} method after checking the

* parent class loader for the requested class(这个方法会被loadClass方法调用，在父类加载器检查了是否加载过后). The default implementation

* throws a <tt>ClassNotFoundException</tt>.

*

* @param name

* The <a href="#name">binary name</a> of the class

*

* @return The resulting <tt>Class</tt> object

*

* @throws ClassNotFoundException

* If the class could not be found

*

* @since 1.2

*/

protected Class<?> findClass(String name) throws ClassNotFoundException {

throw new ClassNotFoundException(name);

}

defineClass()方法

/**

这个方法的作用就是用来把字节数组转为一个Class对象,这个对象

* Converts an array of bytes into an instance of class <tt>Class</tt>.

* Before the <tt>Class</tt> can be used it must be resolved(这个Class对象能被使用必须是经过解析的因为在解析阶段会进行验证). This method

* is deprecated in favor of the version that takes a <a

* href="#name">binary name</a> as its first argument, and is more secure. 就是不推荐用这个方法，而是

推荐用它重写的方法，因为重写方法安全些(因为重写方法中一个参数是我们的是传入二进制模型,他是通过安全域进行保护的)

*

* @param b

* The bytes that make up the class data. The bytes in positions

* <tt>off</tt> through <tt>off+len-1</tt> should have the format

* of a valid class file as defined by

* <cite>The Java&trade; Virtual Machine Specification</cite>.

*

* @param off

* The start offset in <tt>b</tt> of the class data

*

* @param len

* The length of the class data

*

* @return The <tt>Class</tt> object that was created from the specified

* class data

*

* @throws ClassFormatError

* If the data did not contain a valid class

*

* @throws IndexOutOfBoundsException

* If either <tt>off</tt> or <tt>len</tt> is negative, or if

* <tt>off+len</tt> is greater than <tt>b.length</tt>.

*

* @throws SecurityException

* If an attempt is made to add this class to a package that

* contains classes that were signed by a different set of

* certificates than this class, or if an attempt is made

* to define a class in a package with a fully-qualified name

* that starts with "{@code java.}".

*

* @see #loadClass(String, boolean)

* @see #resolveClass(Class)

*

* @deprecated Replaced by {@link #defineClass(String, byte[], int, int)

* defineClass(String, byte[], int, int)}

*/

@Deprecated

protected final Class<?> defineClass(byte[] b, int off, int len)

throws ClassFormatError

{

return defineClass(null, b, off, len, null);

}

以上两个方法在注释中均已经解释。

看完以上的java doc文档，那么我们就可以来写一个自定义的类加载器了。

创建自定义类加载的步骤如下：

1：创建一个类名为Test01ClassLoader，这个是我们自己的类加载器

2：继承ClassLoader类，并且重写findClass方法。

3：创建方法loadClassData构建一个byte[]数组。

4：在findClass中调用父类的defineClass方法，传入相关信息（参数name是名称，传入构建好的byte数组，起始下标从0开始，最后是数组长度）

5：构造函数不能少。如果带参数，意为你指定双亲加载器是谁（类加载器双亲委托模型后面文章中介绍，先记住自定义类加载器的写法和步骤即可）

6：最后就是在main函数中用我们自定义的类加载器去加载我们指定的类来测试。。。

package com.test;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStream;

/**

 * jvm 类加载器 第一章

 * @author 奇客时间-时光

 * 自定义类加载器

 * 1，继承ClassLoader

 * 2，通过构造器指定当前类加载器的父加载器

 * 3，重写findClass方法

 * 4，构造一个byte[]字数

 * 5，调用this.defineClass方法创建classLoader的实例

 */

public class Test01ClassLoader extends ClassLoader {

    private String classLoaderName;

    //声明文件后缀

    private final String x = ".class";

    //声明文件路径

    private String path;

    public void setPath(String path) {

        this.path = path;

    }

    /**

     * 使用默认的类加载器作为当前类加载器的双亲{APPClassLoader作为双亲}

     * @param classLoaderName

     */

    public Test01ClassLoader(String classLoaderName){

        super();//指定系统类加载器为我们的父加载器

        this.classLoaderName = classLoaderName;

    }

    /**

     * 使用我们自己指定的类加载器作为当前类加载器的双亲

     * @param parentClassLoaderNane

     * @param classLoaderName

     */

    public Test01ClassLoader(ClassLoader parentClassLoaderNane,String classLoaderName){

        super(parentClassLoaderNane);

        this.classLoaderName = classLoaderName;

    }

    /**

     * 重写findClass方法，这一步非常重要必不可少

     * @param name

     * @return

     * @throws ClassNotFoundException

     */

    @Override

    protected Class<?> findClass(String name) throws ClassNotFoundException {

        System.out.println("自己的类加载器被加载了");

        byte[] bytes = this.loadClassData(name);

        return this.defineClass(name,bytes,0,bytes.length);

    }

    /**

     * 返回一个字节数字通过给定的类名

     * @param name

     * @return

     */

    private byte[] loadClassData(String name ){

        InputStream inputStream = null;

        byte[] bytes = null;

        ByteArrayOutputStream byteArrayOutputStream = null;

        try {

            name = name.replace(".","\\");

            inputStream= new FileInputStream(this.path+new File(name+this.x));

            byteArrayOutputStream = new ByteArrayOutputStream();

            int ch = 0;

            while(-1 !=(ch= inputStream.read())){

                byteArrayOutputStream.write(ch);

            }

            bytes=byteArrayOutputStream.toByteArray();

        }catch (Exception e){

            e.printStackTrace();

        }finally {

            try {

                inputStream.close();

                byteArrayOutputStream.close();

            }catch (Exception e){

                e.printStackTrace();

            }

        }

        return bytes;

    }

    public static void main(String[] args) throws Exception {

        //创建自定义类加载器的一个实例，并且通过构造器指定名称

        Test01ClassLoader myClassLoader = new Test01ClassLoader("loader1");

        //设置加载路径

        myClassLoader.setPath("I:\\jvm\\out\\production\\jvm-classloader\\");

        //调用loadClass方法来加载我们的class文件

        Class<?> classz = myClassLoader.loadClass("com.test.Dog");

        //通过构造器创建实例

        Object object = classz.getDeclaredConstructor().newInstance();

        //查看我们创建的实例是由哪个类加载器加载的

        System.out.println(object.getClass().getClassLoader());

        /*myClassLoader.setPath("D:\\classes\\");

        Class classz1 = myClassLoader.loadClass("com.jdyun.jvm05.Test");

        Object object1 = classz1.getDeclaredConstructor().newInstance();

        System.out.println(classz1.getClassLoader());

        */

        /*System.out.println(System.getProperty("sun.boot.class.path"));

        System.out.println(System.getProperty("java.ext.dirs"));

        System.out.println(System.getProperty("java.class.path"));

        System.out.println(Test12.getSystemClassLoader());*/

        /*MyTest02[] list = new MyTest02[1];

        System.out.println(list.getClass().getClassLoader());*/

    }

}

上述代码运行结果显示还是通过AppClassLoader来加载的Dog类。那么这是为什么呢？因为我们在构造函数中指定的将系统类加载器也就是我们的AppClassLoader作为我们的双亲，那么根据双亲委托模型，父加载器能加载的类，就由父加载器来加载，所以我们自定义的类加载没有加载到Dog类。（双亲委托模型后面文章会详细介绍。先记住这个结论就好。）

接下来我们对代码进行一点儿改造，来测试我们自定义的类加载是否生效了。

我在G:\jdyun-jvm\out\production\jdyun-jvm\\com\\jdyun\\jvm05\\目录下创建一个class文件Test.class，运行结果如下图所示

我把加载的路径改变，这样我们我们的AppClassloader他只会加载classPath路径下的文件，而我们在外部指定的文件，就自然而然的被我们的自定义类加载器给加载了。

接下来我们对代码进行一下小小的改动，我们创建两个自定义类加载器的实例，然后看看加载出来的Class对象是不是一样的。

public static void main(String[] args) throws Exception {

        //创建自定义类加载器的一个实例，并且通过构造器指定名称

        Test01ClassLoader myClassLoader = new Test01ClassLoader("loader1");

        //设置加载路径

        myClassLoader.setPath("G:\\jdyun-jvm\\out\\production\\jdyun-jvm\\");

        //调用loadClass方法来加载我们的class文件

        Class<?> classz = myClassLoader.loadClass("com.jdyun.jvm05.Test");

        //通过构造器创建实例

        Object object = classz.getDeclaredConstructor().newInstance();

        //查看我们创建的实例是由哪个类加载器加载的

        System.out.println(classz.getClassLoader());

        System.out.println(classz.hashCode());

        //创建自定义类加载器的一个实例，并且通过构造器指定名称

        Test01ClassLoader myClassLoader2 = new Test01ClassLoader("loader1");

        //设置加载路径

        myClassLoader2.setPath("G:\\jdyun-jvm\\out\\production\\jdyun-jvm\\");

        //调用loadClass方法来加载我们的class文件

        Class<?> classz2 = myClassLoader2.loadClass("com.jdyun.jvm05.Test");

        //通过构造器创建实例

        Object object2 = classz2.getDeclaredConstructor().newInstance();

        //查看我们创建的实例是由哪个类加载器加载的

        System.out.println(classz2.getClassLoader());

        System.out.println(classz2.hashCode());

    }

打印结果：

自己的类加载器被加载了

com.test.Test01ClassLoader@1540e19d

21685669

自己的类加载器被加载了

com.test.Test01ClassLoader@7f31245a

325040804

通过上面代码可知，同一个类加载器加载的同一个Class文件加载出来的Class对象不是同一个。并且两个class对象之间也是不能相互转换的。

好了各位小伙伴儿，第一篇文章咱们就先介绍到这里，大家现在了解一下4种类加载器即可，此专题的文章后面还会陆续连载，期待各位小伙伴的阅读。

另外笔者在公众号：奇客时间，给大家收录了1000多道今年互联网公司的面试真题

面试真题-回复关键字形式：公司-部门-面试轮次，例如：阿里-蚂蚁金服-一面，自动回复面试真题；

当前已经收录如下：

字节跳动-抖音-面试轮次, 搜狐-搜索组-面试轮次, OPPO-商城-面试轮次, 58同城-基础架构部-面试轮次,湖南台-芒果TV-面试轮次 , 腾讯-乘车码-面试轮次 , 腾讯-微信支付-面试轮次，腾讯-零售新业务-面试轮次，腾讯-直播平台-面试轮次，快手-广告业务部-面试轮次，贝壳找房-商品组-面试轮次，百度-信息流-面试轮次，京东-零售-面试轮次，京东-物流-面试轮次，京东-电商-面试轮次，滴滴-小桔车服-面试轮次，滴滴-金融-面试轮次，阿里-高德-面试轮次，阿里-大文娱-面试轮次，阿里-健康-面试轮次，阿里-蚂蚁金服-面试轮次，美团-外卖-面试轮次，美团-风控-面试轮次

巴特西

从零造就JVM大牛（一）

引言

一：类加载

类型加载：这里的类型指的的是什么呢？

类型的来源有哪些？类型的来源我总结了以下7点内容

那么我们的是通过什么进行加载的呢？是如何被加载到jvm中的呢？

首先我们来了解以下类加载器的种类？系统级别的类加载器如下

非系统级别类加载器如下：

一：启动类加载器（Bootstrap Classloader）重点剖析

二：扩展类加载器（Extention ClassLoader）重点剖析

三：应用类加载器（APP ClassLoader）重点剖析

四：我们自定义的类加载器

4.1：ClassLoader抽象类文档解读

4.2：我们的ClassLoader类加载器重要方法详解

最新文章

热门文章

巴特西

从零造就JVM大牛（一）

引言

一：类加载

类型加载：这里的类型指的的是什么呢？

类型的来源有哪些？类型的来源我总结了以下7点内容

那么我们的是通过什么进行加载的呢？是如何被加载到jvm中的呢？

首先我们来了解以下类加载器的种类？系统级别的类加载器如下

非系统级别类加载器如下：

一：启动类加载器（Bootstrap Classloader）重点剖析

二：扩展类加载器（Extention ClassLoader）重点剖析

三：应用类加载器（APP ClassLoader）重点剖析

四：我们自定义的类加载器

4.1：ClassLoader抽象类 文档解读

4.2：我们的ClassLoader类加载器重要方法详解

最新文章

热门文章

4.1：ClassLoader抽象类文档解读