JVM解惑-JVM类加载过程
ps：本篇主要参考知乎大佬的java类加载机制，源码和引用部分为自己总结！
此文源码均为jdk1.8为例
1 类加载过程
1.1 jvm模型
JVM由红色标线部分组成,除了类装载器和执行引擎外，其余统称为运行时数据区。运行时数据区又分为线程共享和非共享部分。共享部分包括堆和方法区（1.8后称为元空间），其余虚拟机栈，本地方法栈以及程序计数器为线程独有。
1.2. 类加载过程
类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个 Class对象，用来封装类在方法区内的数据结构的过程。
类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载、验证、准备、解析、初始化、使用和卸载七个阶段。
其中类加载的过程包括了加载、验证、准备、解析、初始化五个阶段。在这五个阶段中，加载、验证、准备和初始化这四个阶段发生的顺序是确定的，而解析阶段则不一定，它在某些情况下可以在初始化阶段之后开始。另外注意这里的几个阶段是按顺序开始，而不是按顺序进行或完成，因为这些阶段通常都是互相交叉地混合进行的，通常在一个阶段执行的过程中调用或激活另一个阶段。
1.2.1、加载
”加载“是”类加机制”的第一个过程，在加载阶段，虚拟机主要完成三件事：
（1）通过一个类的全限定名来获取其定义的二进制字节流
（2）将这个字节流所代表的的静态存储结构转化为方法区的运行时数据结构
（3）在堆中生成一个代表这个类的Class对象，作为方法区中这些数据的访问入口。
相对于类加载的其他阶段而言，加载阶段是可控性最强的阶段，因为程序员可以使用系统的类加载器加载，还可以使用自己的类加载器加载。我们在最后一部分会详细介绍这个类加载器。在这里我们只需要知道类加载器的作用就是上面虚拟机需要完成的三件事，仅此而已就好了。
1.2.2、验证
验证的主要作用就是确保被加载的类的正确性。也是连接阶段的第一步。说白了也就是我们加载好的.class文件不能对我们的虚拟机有危害，所以先检测验证一下。他主要是完成四个阶段的验证：
（1）文件格式的验证：验证.class文件字节流是否符合class文件的格式的规范，并且能够被当前版本的虚拟机处理。这里面主要对魔数、主版本号、常量池等等的校验（魔数、主版本号都是.class文件里面包含的数据信息、在这里可以不用理解）。
（2）元数据验证：主要是对字节码描述的信息进行语义分析，以保证其描述的信息符合java语言规范的要求，比如说验证这个类是不是有父类，类中的字段方法是不是和父类冲突等等。
（3）字节码验证：这是整个验证过程最复杂的阶段，主要是通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。在元数据验证阶段对数据类型做出验证后，这个阶段主要对类的方法做出分析，保证类的方法在运行时不会做出威海虚拟机安全的事。
（4）符号引用验证：它是验证的最后一个阶段，发生在虚拟机将符号引用转化为直接引用的时候。主要是对类自身以外的信息进行校验。目的是确保解析动作能够完成。
对整个类加载机制而言，验证阶段是一个很重要但是非必需的阶段，如果我们的代码能够确保没有问题，那么我们就没有必要去验证，毕竟验证需要花费一定的的时间。当然我们可以使用-Xverfity:none来关闭大部分的验证。
1.2.3、准备
准备阶段主要为类变量分配内存并设置初始值。这些内存都在方法区分配。在这个阶段我们只需要注意两点就好了，也就是类变量和初始值两个关键词：
（1）类变量（static）会分配内存，但是实例变量不会，实例变量主要随着对象的实例化一块分配到java堆中，
（2）这里的初始值指的是数据类型默认值，而不是代码中被显示赋予的值。比如
public static int value = 1; //在这里准备阶段过后的value值为0，而不是1。赋值为1的动作在初始化阶段。
当然还有其他的默认值。
注意，在上面value是被static所修饰的准备阶段之后是0，但是如果同时被final和static修饰准备阶段之后就是1了。我们可以理解为static final在编译器就将结果放入调用它的类的常量池中了。
1.2.4、解析
解析阶段主要是虚拟机将常量池中的符号引用转化为直接引用的过程。什么是符号应用和直接引用呢？
符号引用：以一组符号来描述所引用的目标，可以是任何形式的字面量，只要是能无歧义的定位到目标就好，就好比在班级中，老师可以用张三来代表你，也可以用你的学号来代表你，但无论任何方式这些都只是一个代号（符号），这个代号指向你（符号引用）
直接引用：直接引用是可以指向目标的指针、相对偏移量或者是一个能直接或间接定位到目标的句柄。和虚拟机实现的内存有关，不同的虚拟机直接引用一般不同。
解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行。
1.2.5、初始化
这是类加载机制的最后一步，在这个阶段，java程序代码才开始真正执行。我们知道，在准备阶段已经为类变量赋过一次值。在初始化阶端，程序员可以根据自己的需求来赋值了。一句话描述这个阶段就是执行类构造器< clinit >()方法的过程。
在初始化阶段，主要为类的静态变量赋予正确的初始值，JVM负责对类进行初始化，主要对类变量进行初始化。在Java中对类变量进行初始值设定有两种方式：
①声明类变量是指定初始值
②使用静态代码块为类变量指定初始值
JVM初始化步骤
1、假如这个类还没有被加载和连接，则程序先加载并连接该类
2、假如该类的直接父类还没有被初始化，则先初始化其直接父类
3、假如类中有初始化语句，则系统依次执行这些初始化语句
类初始化时机：只有当对类的主动使用的时候才会导致类的初始化，类的主动使用包括以下六种：
创建类的实例，也就是new的方式
访问某个类或接口的静态变量，或者对该静态变量赋值
调用类的静态方法
反射（如 Class.forName(“com.shengsiyuan.Test”)）
初始化某个类的子类，则其父类也会被初始化
Java虚拟机启动时被标明为启动类的类（ JavaTest），直接使用 java.exe命令来运行某个主类
好了，到目前为止就是类加载机制的整个过程，但是还有一个重要的概念，那就是类加载器。在加载阶段其实我们提到过类加载器，说是在后面详细说，在这就好好地介绍一下类加载器。
2.类加载器以及双亲委派部分源码
虚拟机设计团队把加载动作放到JVM外部实现，以便让应用程序决定如何获取所需的类。
2.2.1、Java语言系统自带有三个类加载器:
- Bootstrap ClassLoader ：最顶层的加载类，主要加载核心类库，也就是我们环境变量下面%JRE_HOME%\lib下的rt.jar、resources.jar、charsets.jar和class等。另外需要注意的是可以通过启动jvm时指定-Xbootclasspath和路径来改变Bootstrap ClassLoader的加载目录。比如java -Xbootclasspath/a:path被指定的文件追加到默认的bootstrap路径中。我们可以打开我的电脑，在上面的目录下查看，看看这些jar包是不是存在于这个目录。
- Extention ClassLoader ：扩展的类加载器，加载目录%JRE_HOME%\lib\ext目录下的jar包和class文件。还可以加载-D java.ext.dirs选项指定的目录。
- Appclass Loader：也称为SystemAppClass。 加载当前应用的classpath的所有类。
我们看到java为我们提供了三个类加载器，应用程序都是由这三种类加载器互相配合进行加载的，如果有必要，我们还可以加入自定义的类加载器。这三种类加载器的加载顺序是什么呢？
Bootstrap ClassLoader > Extention ClassLoader > Appclass Loader
2.2.2、类加载的三种方式
认识了这三种类加载器，接下来我们看看类加载的三种方式。
（1）通过命令行启动应用时由JVM初始化加载含有main()方法的主类。
（2）通过Class.forName()方法动态加载，会默认执行初始化块（static{}），但是Class.forName(name,initialize,loader)中的initialze可指定是否要执行初始化块。
（3）通过ClassLoader.loadClass()方法动态加载，不会执行初始化块。
下面为测试代码
类1
public class ClassLoaderTest {
public static int init;
static {
System.out.println("我是初始化代码！！！");
init = 10;
}
public static void loadClass() {
System.out.println("开始加载classLoader测试类!!!init的值为："+init);
}
}
类2
public class ClassLoaderMain {
public static void main(String[] args) throws Exception{
System.out.println("我是分割线1=========================");
ClassLoader classLoader = Dog.class.getClassLoader();
Class<?> aClass1 = classLoader.loadClass("com.hex.math.classloader.ClassLoaderTest");
Method loadClass1 = aClass1.getDeclaredMethod("loadClass");
// loadClass1.invoke(aClass1); --当方法被调用的时候会初始化静态代码块
System.out.println("我是分割线2=========================");
// ClassLoaderTest.loadClass(); //当方法被调用的时候会初始化静态代码块
System.out.println("我是分割线3=========================");
Class<?> aClass = Class.forName("com.hex.math.classloader.ClassLoaderTest",false,classLoader);
System.out.println("我是分割线4=========================");
Method loadClass = aClass.getDeclaredMethod("loadClass");//当方法被调用的时候会初始化静态代码块
System.out.println("我是分割线5=========================");
loadClass.invoke(aClass);
}
}
执行结果
总结一下
类加载器将类加载进内存，并不一定立即进行初始化，但类中方法被调用时，一定能保证这个类是初始化过的。
2.2.3、双亲委派原则
当一个类加载器收到类加载任务，会先交给其父类加载器去完成，因此最终加载任务都会传递到顶层的启动类加载器，只有当父类加载器无法完成加载任务时，才会尝试执行加载任务。
采用双亲委派的一个好处是比如加载位于rt.jar包中的类java.lang.Object，不管是哪个加载器加载这个类，最终都是委托给顶层的启动类加载器进行加载，这样就保证了使用不同的类加载器最终得到的都是同样一个Object对象。
双亲委派原则归纳一下就是：
- 可以避免重复加载，父类已经加载了，子类就不需要再次加载
- 更加安全，很好的解决了各个类加载器的基础类的统一问题，如果不使用该种方式，那么用户可以随意定义类加载器来加载核心api，会带来相关隐患。
下面为源码分析：
java.lang.ClassLoader#loadClass(此处为jdk1.8)
ps:这里只贴出了我认为可以解释双亲委派原则的代码，其他不重要的就直接干掉了。
//parent默认为空，classLoader私有构造方法可以初始化parent，不提供对外调用。默认会初始化为自己（java.lang.ClassLoader）。
private final ClassLoader parent;
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
//先看下类是否已经被加载过，如果加载过直接返回class
Class<?> c = findLoadedClass(name);
if (c == null) {
try {
if (parent != null) {
//第一次调用自己的loadClass
c = parent.loadClass(name, false);
} else {
/**第二次进来parent为空，走此处调用native方法去父类
bootStrap ClassLoader加载类，异常被catch，只有加载不到才会依次去子类加载。**/
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// 如果加载不到会调用findClass找寻自定义加载器，如果再加载不到会抛出异常。
c = findClass(name);
}
}
return c;
}
}
加载顺序从上往下：Bootstrap ClassLoader > Extention ClassLoader > Appclass Loader
3.自定义类加载器
我们如何自己定义类加载器呢？这主要有两种方式
（1）遵守双亲委派模型：继承ClassLoader，重写findClass()方法。
（2）破坏双亲委派模型：继承ClassLoader,重写loadClass()方法。 通常我们推荐采用第一种方法自定义类加载器，最大程度上的遵守双亲委派模型。
我们看一下实现步骤
（1）创建一个类继承ClassLoader抽象类
（2）重写findClass()方法
（3）在findClass()方法中调用defineClass()
类一
public class Person {
public Person() {
}
public void test() {
System.out.println("test success!!");
}
}
类二
public class MyPersonClassLoader extends ClassLoader {
private String filePath;
public MyPersonClassLoader(String filePath) {
this.filePath = filePath;
}
//loadClass为加载类的方法，但是如果重写loadClass会破坏java原有的双亲委派原则。
//因此我们重写findClass方法，在不破坏双亲原则的情况下加载我们需要的自定义类。
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
System.out.println("进入自定义加载器...........");
Class<?> personClass = null;
byte[] data = findPersonData();
if (data != null) {
//加载类后调用defineClass（final方法）将class的字节码数组转换成Class类的实例
personClass = defineClass(name, data, 0, data.length);
}
return personClass;
}
private byte[] findPersonData() {
File file = new File(filePath);
if (file.exists() && file.isFile()) {
FileInputStream in = null;
FileOutputStream out = null;
ByteArrayOutputStream bout = null;
try {
in = new FileInputStream(file);
out = new FileOutputStream("E://aaa.txt");
bout = new ByteArrayOutputStream();
//定义缓存数组
byte[] buffer = new byte[1024];
int size = 0;
while ((size = in.read(buffer)) != -1) {
out.write(buffer, 0, size);
bout.write(buffer, 0, size);
}
out.flush();//刷出缓存到文件
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
in.close();
out.close();
bout.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return bout.toByteArray();
}
return null;
}
public static void main(String[] args) throws Exception{
MyPersonClassLoader myPersonClassLoader = new MyPersonClassLoader("E://Person.class");
String packageNamePath = "com.hex.math.Person";
//加载Log这个class文件
Class<?> person = myPersonClassLoader.loadClass(packageNamePath);
System.out.println("类加载器是:" + person.getClassLoader());
//利用反射获取main方法
Method method = person.getDeclaredMethod("test");
Object object = person.newInstance();
method.invoke(object);
}
}
需要注意的点:
Person这个类在项目中不能存在,否则会通过父类Appclass Loader加载,而不会调用自定义加载器