JVM——02类加载子系统

一、类加载子系统

 类加载子系统负责从文件系统或者网络中加载.class文件，.class文件在文件开头有特定的文件标识(CA FE BA BE)。
 ClassLoader只负责.class文件的加载，至于它是否可以运行，则由执行引擎(Execution Engine)决定。
 加载的类信息存放于一块称为方法区的内存空间(JDK8将其置于元空间)中，除了类的信息外，方法区中还会存放运行时常量池信息，可能还包括字符串字面量和数字常量(这部分常量信息是.class文件中常量池部分的内存映射)。

二、类的加载过程

 大体上，类的加载分为加载、链接、初始化三个阶段。
 1、加载(Loading)阶段：在加载阶段主要完成如下三个任务
  ①通过一个类的全限定名获取定义此类的二进制字节流：即通过全类名定位到.class文件的位置
  ②将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
  ③在内存中生成一个代表这个类的java.class.Class对象，作为方法区中这个类的各种数据的访问入口
  加载.class文件的方式：
  a、从本地系统中直接加载
  b、通过网络获取，如：Web Applet
  c、从zip压缩包中读取：成为日后jar、war格式的基础
  d、运行时计算生成，如：动态代理
  e、由其他文件生成，如：jsp
  f、从专有数据库中提取.class(比较少见)
  g、从加密文件中获取：是典型的防止.class文件被反编译的保护源码的措施
 2、链接(Linking)阶段：链接阶段又可细分为三个小阶段
  ①验证(Verify)：目的在于确保.class文件的字节流中包含的信息符合当前虚拟机的要求(如是否有特定的文件标识等)，保证被加载的类的正确性(不会危害虚拟机自身安全)。验证主要包括四种：文件格式验证、元数据验证、字节码验证、符号引用验证
  ②准备(Prepare)：为类变量分配内存并且为其设置默认初始值，即零值(数值型的基本数据类型设置为0、布尔类型为false、引用类型为null)
   注意：这里只会为类变量，即用static修饰的变量(不含final修饰的static变量，final修饰的static变量在编译时就会分配，且在准备阶段会显示初始化)分配内存，不会为成员变量分配内存，成员变量是在类实例化的时候随着对象一起分配到Java堆中的。此外准备阶段仅仅是为类变量分配内存和设置默认初始值，但不会将其初始化为指定的值，初始化是在下一个阶段进行的。

public class Hello{
	//a的值在准备阶段是0，在初始化阶段才是10
    public static int a = 10;
}

  ③解析(Resolve)：将常量池内的符号引用转换为直接引用的过程。事实上，解析操作往往会伴随着JVM在执行完初始化之后再执行。符号引用就是用一组符号来描述所引用的目标，符号引用的字面量形式明确定义在《java虚拟机规范》的class文件格式中。直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。解析动作主要针对类或接口、字段、类方法、接口方法、方法类型等，对应常量池中的CONSTANT_Class_info、CONSTANT_Fieldref_info、CONSTANT_Methodref_info等
 3、初始化(Initialization)阶段：初始化阶段就是执行类构造器方法<clinit>()的过程，此方法不需定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来的。类构造器方法中的指令按语句在源文件中出现的顺序执行。<clinit>()不同于类的构造器，构造器是虚拟机视角下的<init>()方法。若该类具有父类，JVM会保证子类的<clinit>()执行前，父类的<clinit>()已经执行完毕。虚拟机必须保证一个类的<clinit>()方法在多线程下被同步加锁执行

public class MainTest {
    static{
        num = 20;
    }
    public static int num = 10;
}

  上面的代码不会报错的原因就是javac编译器会自动收集类中的所有类变量的赋值动作和静态代码块中的语句，并将二者合并，编译之后的结果(MainTest.class)如下：

public class MainTest {
    public static int num = 20;
    public MainTest() {
    }
    static {
        num = 10;
    }
}

  使用jclasslib查看对应的字节码如下：在对代码的执行过程有疑惑的时候可以使用jclasslib来查看字节码进行分析

  tips：类变量num的值在链接的准备阶段被设置为0，初始化阶段先初始化为20，后又初始化为10，但是需要注意的是类变量在声明之前可以在静态代码块中初始化它的值，但是不能在声明之前使用它，如下代码就会报错：

public class MainTest {
    static{
        num = 20;
        //System.out.println(num);报错：非法的前向引用
    }
    public static int num = 10;
}

三、类的加载器
 JVM支持两种类型的类加载器，分别为引导类加载器(Bootstrap ClassLoader)和自定义类加载器(User-Defined ClassLoader)。从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器，但是Java虚拟机规范却没有这么定义，而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器(包含扩展类加载器、应用类加载器和开发人员自定义的类加载器)。无论类加载器的类型如何划分，在程序中我们最常见的类加载器始终只有3个：引导类加载器、扩展类加载器和应用类加载器
 需要注意的是：类的加载器并不是继承关系，可以理解为是一种等级关系。引导类加载器是用C++编写实现的，其他的类加载器则是由Java编写实现的。

 如上图所示：扩展类加载器(ExtClassLoader)和应用类加载器(AppClassLoader)都是Launcher类的静态内部类，AppClassLoader并没有继承ExtClassLoader，但是AppClassLoader和ExtClassLoader都继承自URLClassLoader：

 由Java实现的类加载器是可以通过API获取到的，但是C++实现的引导类加载器是无法获取到的：

public class MainTest {
    public static void main(String[] args) {
        // 获取应用类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);// sun.misc.Launcher$AppClassLoader@18b4aac2

        // 获取扩展类加载器
        ClassLoader extClassLoader = systemClassLoader.getParent();
        System.out.println(extClassLoader);// sun.misc.Launcher$ExtClassLoader@39a054a5

        // 获取引导类加载器
        ClassLoader bootstrapClassLoader1 = extClassLoader.getParent();
        System.out.println(bootstrapClassLoader1);// null

        // 获取核心类String的加载器：Java中的核心类库都是由引导类加载器加载的
        ClassLoader bootstrapClassLoader2 = String.class.getClassLoader();
        System.out.println(bootstrapClassLoader2);// null

        // 获取用户自定义类的类加载器：用户自定义的类的类加载器默认是由应用类加载器加载的
        ClassLoader classLoader = MainTest.class.getClassLoader();
        System.out.println(classLoader);// sun.misc.Launcher$AppClassLoader@18b4aac2
    }
}

 ClassLoader中的几个方法及其作用：

方法名称	作用描述
getParent()	获取当前类加载器的父类加载器
loadClass(String name)	加载名称为name的类，返回java.lang.Class类的实例
findClass(String name)	查找名称为name的类，返回java.lang.Class类的实例
findLoadedClass(String name)	查找名称为name的已被加载过的类，返回java.lang.Class类的实例
defineClass(String name,byte[] b,int off,int len)	把字节数组b中的内容转换为一个Java类，返回java.lang.Class类的实例
resolveClass(Class<?> c)	连接指定的Java类

 获取ClassLoader的途径：

方式	描述
clazz.getClassLoader()	获取当前类的类加载器
Thread.currentThread().getContextClassLoader()	获取当前线程上下文的类加载器
ClassLoader.getSystemClassLoader()	获取系统类加载器(即应用类加载器)
DriverManager.getCallerClassLoader()	获取调用者的类加载器

四、类加载器的分类
 1、虚拟机自带的加载器
  ①启动类加载器(或引导类加载器，Bootstrap ClassLoader)
   Bootstrap ClassLoader 使用C/C++语言实现，嵌套在JVM内部，可以说是JVM的一部分。它用来加载Java的核心类库(JAVA_HOME/jre/lib/rt.jar、resources.jar或sun.boot.class.path路径下的内容)，用于提供JVM自身需要的类。Bootstrap ClassLoader并不继承自java.lang.ClassLoader，它没有父加载器。扩展类加载器和应用类加载器是通过它来加载的。出于安全考虑，Bootstrap ClassLoader只加载包名以java、javax、sun等开头的类。
  ②扩展类加载器(Extension ClassLoader)
   扩展类加载器是Java语言编写的，由sun.misc.Launcher$ExtClassLoader(即类Launcher中的静态内部类ExtClassLoader)实现。扩展类加载器派生于ClassLoader类，启动类加载器是它的父类加载器。扩展类加载器从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录下的jre/lib/ext子目录(扩展目录)下加载类库。如果用户将自己创建的jar放在此目录下，也会自动由扩展类加载器加载。
  ③应用类加载器(或系统类加载器，AppClassLoader)
   应用类加载器也是java语言编写的，由sun.misc.Launcher$AppClassLoader实现，也派生于ClassLoader类。应用类加载器的父类加载器指定为扩展类加载器(ExtClassLoader)，它负责加载环境变量为classpath或系统属性为java.class.path指定路径下的类库。该类加载器是程序中默认的类加载器，一般来说，Java应用中的类都是由它来完成加载的。通过ClassLoader#getSystemClassLoader()方法可以获取到该类加载器。

public void loaderDir() throws Exception {
	//获取Bootstrap ClassLoader加载的类库的所有路径
	URL[] urLs = sun.misc.Launcher.getBootstrapClassPath().getURLs();
	for(URL url : urLs){
		System.out.println(url.toExternalForm());
	}
//		file:/E:/jdk/jdk1.8.0_121/jre/lib/resources.jar
//		file:/E:/jdk/jdk1.8.0_121/jre/lib/rt.jar
//		file:/E:/jdk/jdk1.8.0_121/jre/lib/sunrsasign.jar
//		file:/E:/jdk/jdk1.8.0_121/jre/lib/jsse.jar
//		file:/E:/jdk/jdk1.8.0_121/jre/lib/jce.jar
//		file:/E:/jdk/jdk1.8.0_121/jre/lib/charsets.jar
//		file:/E:/jdk/jdk1.8.0_121/jre/lib/jfr.jar
//		file:/E:/jdk/jdk1.8.0_121/jre/classes
	
	//获取扩展类加载器的加载目录
	String dirs = System.getProperty("java.ext.dirs");
	for(String dir : dirs.split(";")){
		System.out.println(dir);
	}
	
//		E:\jdk\jdk1.8.0_121\jre\lib\ext
//		C:\WINDOWS\Sun\Java\lib\ext
}

  由此可见，启动类加载器、扩展类加载器和应用类加载器加载类库的路径不同。
 2、用户自定义类加载器
  在Java应用程序的日常开发中，类的加载几乎都是由上述3种类加载器相互配合完成的。但在必要时，我们还可以自定义类加载器，来定制类的加载方式。为什么要自定义类加载器呢？主要有以下几个功用：
  1️⃣隔离加载类
  2️⃣修改类加载的方式
  3️⃣扩展加载源
  4️⃣防止源码泄露：使用自定义类加载器可以进行字节码文件的加解密
  自定义类加载器有以下几种方式：
  1️⃣继承抽象类java.lang.ClassLoader，实现自己的类加载器
  2️⃣在JDK1.2之前，在自定义类加载器时，总会去继承ClassLoader类并重写loadClass()方法，从而实现自定义的类加载器，但是在JDK1.2之后已不再建议用户去覆盖loadClass()方法，而是建议把自定义的类加载逻辑写在findClass()方法中
  3️⃣在编写自定义类加载器时，如果没有太过于复杂的需求，可以直接继承URLClassLoader类，这样就可以避免自己去编写findClass()方法以及获取字节码流的方式，使自定义类加载器的编写更加简洁

public class CustomClassLoader extends ClassLoader {
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		try {
			byte[] result = getClassFromCustomPath(name);
			if (result == null) {
				throw new FileNotFoundException();
			} else {
				return defineClass(name, result, 0, result.length);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		throw new ClassNotFoundException(name);
	}
}

五、双亲委派机制
 Java虚拟机对class文件采用的是按需加载的方式，也就是说当需要使用某类的时候才会将它的class文件加载到内存并生成Class对象。在加载某个类的class文件时，Java虚拟机采用的是双亲委派模式，即把加载请求先交由父类处理，是一种任务委派模式。

 双亲委派机制的原理：
 ①如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行
 ②如果父类加载器还存在父类加载器，则进一步向上委托，加载请求最终将到达顶层的启动类加载器
 ③如果父类加载器可以完成类的加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载
 双亲委派机制的优势：
 ①避免类的重复加载
 ②保护程序安全，防止核心API被随意篡改
  比如我们自定义一个类：java.lang.String，这个类是不会被加载的，因为java.lang包下的类都会由启动类加载器加载，而启动类加载器会加载jre/lib/rt.jar下的String类，而不会加载我们自定义的这个String类，这样就起到了保护核心API的作用。此外Java虚拟机还会对java.lang等包做一些安全性保护，我们不可以自定义一个类的包名叫java.lang等，会报java.lang.SecurityException:Prohibited package name:java.lang异常。

 如上图所示：jdbc的接口标准是由Java核心类库定义的，但是具体的实现却是由各个厂商或用户自己实现的，因此在加载时会出现接口由引导类加载器加载，而具体实现由应用类加载器加载的情况。
 双亲委派机制为要加载的类库尤其是Java核心类库创建了一个安全的沙箱，从而起到安全保护作用。有了双亲委派机制，可以保证核心类库不会受到外界干扰和污染，相当于将核心类库放在了一个安全的沙箱中。
 Tips：
  ①在JVM中表示两个Class对象是否相等有两个必要条件：一是这两个类的完整类名必须一致；二是加载这两个类的ClassLoader必须相同。换句话说，在JVM中，即使两个类对象(java.lang.Class对象)来自同一个class文件，又被加载到同一个虚拟机中，但只要加载它们的ClassLoader实例不同，那么这两个类对象也是不相等的。
  ②JVM必须知道一个类型是由启动类加载器加载的还是由用户类加载器加载的。如果一个类型是由用户类加载器加载的，那么JVM会将这个类加载器的一个引用作为类型信息的一部分保存在方法区中。当解析一个类型到另一个类型的引用的时候，JVM需要保证这两个类型的类加载器是相同的。

六、类的主动使用和被动使用
 Java程序对类的使用方式分为：主动使用和被动使用，区别在于会不会执行类的初始化操作，即被动使用类时不会执行静态代码块中的语句等。主动使用，有以下七种情况：
 ①创建类的实例
 ②访问某个类或接口的静态变量，或者对该静态变量赋值
 ③调用类的静态方法
 ④反射(如Class.forName(“com.bdm.Test”))
 ⑤初始化一个类的子类
 ⑥Java虚拟机启动时被标明为启动类的类
 ⑦JDK7开始提供动态语言支持：java.lang.invoke.MethodHandle实例的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic句柄对应的类没有初始化，则初始化
 除了以上其中情况，其他使用Java类的方式都被看做是对类的被动使用，都不会导致类的初始化。