深入类加载机制

深入类加载机制

初识类加载过程

使用某个类时，如果该类的class文件没有加载到内存时，则系统会通过以下三个步骤来对该类进行初始化

1.类的加载（Load） → 2.类的连接（Link） → 3.类的初始化（Initialize）

  • 类的加载（Load）：将类的class文件读入内存，并为之创建一个java.lang.Class的对象，此过程由类加载器（ClassLoader ）完成
  • 类的连接（Link）：将类中的数据加载到各个内存区域中
  • 类的初始化（Initialize）：JVM负责对类进行初始化

深入类加载过程

类的完整生命周期 ：加载、连接（验证、准备、解析）、初始化、使用、卸载

  1. 加载

    1. 通过一个类的全限定名来获取其定义的二进制字节流

    2. 将这个字节流所代表的的静态存储结构转化为方法区的运行时数据结构

    3. 在堆中生成一个代表这个类的Class对象，作为方法区中这些数据的访问入口

    4. 注意： 相对于类加载过程的其他阶段而言，加载阶段是可控性最强的阶段，因为程序员可以使用系统的类加载器加载，还可以使用自己的类加载器加载，在这里我们只需要知道类加载器的作用就是上面虚拟机需要完成的三件事

  2. 连接

    1. 验证

      1. 文件格式的验证：验证.class文件字节流是否符合class文件的格式的规范，并且能够被当前版本的虚拟机处理

      2. 元数据验证：主要是对字节码描述的信息进行语义分析，以保证其描述的信息符合java语言规范的要求，比如说验证这个类是不是有父类，类中的字段方法是不是和父类冲突等等。

      3. 字节码验证：这是整个验证过程最复杂的阶段，主要是通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。在元数据验证阶段对数据类型做出验证后，这个阶段主要对类的方法做出分析，保证类的方法在运行时不会做出威胁虚拟机安全的事。

      4. 符号引用验证：它是验证的最后一个阶段，发生在虚拟机将符号引用转化为直接引用的时候。主要是对类自身以外 （常量池中的各种符号引用） 的信息进行校验。目的是确保解析动作能够完成。

      5. 注意： 对整个类加载机制而言，验证阶段是一个很重要但是非必需的阶段，如果我们的代码能够确保没有问题，那么我们就没有必要去验证，毕竟验证需要花费一定的的时间。当然我们可以使用

        -Xverfty:none来关闭大部分的验证。

    2. 准备 - 重要

      准备阶段主要为类变量（static）分配内存并设置初始值。这些内存都在方法区分配。在这个阶段我们只需要注意两点就好了，类变量和初始值两个关键词：

      1. 类变量（static）：会分配内存，但不会对应的分配值，其次实例变量不会分配空间，因为实例变量主要随着对象的实例化一块分配到java堆内存中

      2. 初始值：这里的初始值指的是数据类型默认值，而不是代码中被显示赋予的值

      比如1：public static int value = 1;

      在这里准备阶段过后的value值为0，而不是1赋值为1的动作在初始化阶段

      比如2：public static final int value = 1;

      同时被final和static修饰准备阶段之后就是1了，因为static final在编译器就将结果放入调用它的类的常量池中

    3. 解析

      解析阶段主要是虚拟机将常量池中的符号引用转化为直接引用的过程

      1. 符号引用：以一组符号来描述所引用的目标，可以是任何形式的字面量，只要是能无歧义的定位到目标就好，就好比在班级中，老师可以用张三来代表你，也可以用你的学号来代表你，但无论任何方式这些都只是一个代号（符号），这个代号指向你（符号引用）
      2. 直接引用：直接引用是可以指向目标的指针、相对偏移量或者是一个能直接或间接定位到目标的句柄。和虚拟机实现的内存有关，不同的虚拟机直接引用一般不同
      3. 补充： 解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行

    4. 初始化

      这是类加载机制的最后一步，在这个阶段，java程序代码才开始真正执行。在准备阶段已经为类变量赋过一次值。在初始化阶端，程序员可以根据自己的需求来赋值了。一句话描述这个阶段就是执行类构造器clinit()方法的过程。

      在初始化阶段，主要为类的静态（stitic）变量赋予正确的初始值，JVM负责对类进行初始化，主要对类变量（stitic）进行初始化。在Java中对类变量进行初始值设定有两种方式：

      1. 声明类变量是指定初始值
      2. 使用静态代码块为类变量指定初始值

      补充：clinit() 方法具有以下特点：

      1. 由编译器自动收集类中所有类变量（static）的赋值动作和静态语句块（static{} 块）中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定。特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码

        1
        2
        3
        4
        5
        6
        7
        class Test {
        	static {
        		i = 0;                // 给变量赋值可以正常编译通过
        		System.out.print(i);  // 这句编译器会报错，提示“非法向前引用”
        	}
        	static int i = 1;
        }

      2. 与类的构造函数（或者说实例构造器 init()）不同，不需要显式的调用父类的构造器。虚拟机会自动保证在子类的 clinit() 方法运行之前，父类的 clinit() 方法已经执行结束。因此虚拟机中第一个执行 clinit() 方法的类肯定为 java.lang.Object。由于父类的 clinit() 方法先执行，也就意味着父类中定义的静态语句块要优于子类的变量赋值操作。例如以下代码：

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        public class Test {
        	public static void main(String[] args) {
        	     System.out.println(Son.B);//输出结果是父类中的静态变量A的值，也就是2
        	}
        }
        class Father{
            public static int A = 1;
            static {
            	System.out.println("a");
                A = 2;
            }
        }
        class son extends Father {
            public static int B = A;
            
        }

      3. clinit() 方法对于类或接口不是必须的，如果一个类中不包含静态语句块，也没有对类变量的赋值操作，编译器可以不为该类生成 clinit() 方法。

      4. 接口中不可以使用静态语句块，但仍然有类变量初始化的赋值操作，因此接口与类一样都会生成 clinit() 方法。但接口与类不同的是，执行接口的() 方法不需要先执行父接口的 clinit() 方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的 clinit() 方法。

      5. 虚拟机会保证一个类的 clinit() 方法在多线程环境下被正确的加锁和同步，如果多个线程同时初始化一个类，只会有一个线程执行这个类的 clinit() 方法，其它线程都会阻塞等待，直到活动线程执行 clinit() 方法完毕。如果在一个类的 clinit() 方法中有耗时的操作，就可能造成多个线程阻塞，在实际过程中此种阻塞很隐蔽。

      6. JVM初始化步骤：

        1. 假如这个类还没有被加载和连接，则程序先加载并连接该类
2. 假如该类的直接父类还没有被初始化，则先初始化其直接父类
3. 假如类中有初始化语句，则系统依次执行这些初始化语句

      7. 类初始化时机：

        只有当对类的主动使用的时候才会导致类的初始化，类的主动使用包括以下六种：

        1. 创建类的实例，也就是new的方式

        2. 访问某个类或接口的静态变量，或者对该静态变量赋值

        3. 调用类的静态方法

        4. 反射

        5. 初始化某个类的子类，则其父类也会被初始化

        6. Java虚拟机启动时被标明为启动类的类，直接使用 java.exe命令来运行某个主类

          比如：测试类Test

  3. 使用： 当 JVM 完成初始化阶段之后，JVM 便开始从入口方法开始执行用户的程序代码

  4. 卸载： 当用户程序代码执行完毕后，JVM 便开始销毁创建的 Class 对象，最后负责运行的 JVM 也退出内存

利用类加载过程理解面试题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class Test {
	public static void main(String[] args) {
		A a = A.getInstance();
        System.out.println("A value1:" + a.value1);//1
        System.out.println("A value2:" + a.value2);//0

        B b = B.getInstance();
        System.out.println("B value1:" + b.value1);//1
        System.out.println("B value2:" + b.value2);//1
	}
}
class A{
    private static A a = new A();
    public static int value1;	
    public static int value2 = 0;

    private A(){
        value1++;
        value2++;
    }

    public static A getInstance(){
        return a;
    }
}
class B{
    public static int value1;
    public static int value2 = 0;
    private static B b = new B();

    private B(){
        value1++;
        value2++;
    }
    public static B getInstance(){
        return b;
    }

}

类加载器

类加载器实现的功能是即为加载阶段获取二进制字节流的时候,在 Java 虚拟机外部实现，以便让应用程序自己决定如何去获取所需要的类。

类加载器分类

从 Java 虚拟机的角度来讲，只存在以下两种不同的类加载器：

  1. 启动类加载器（Bootstrap ClassLoader）：这个类加载器用 C++ 实现，是虚拟机自身的一部分
  2. 所有其他类的加载器，这些类由 Java 实现，独立于虚拟机外部，并且全都继承自抽象类 java.lang.ClassLoader

从 Java 开发人员的角度看，类加载器可以划分得更细致一些：

  1. 启动类加载器（Bootstrap ClassLoader）： 最顶层的类加载器，负责加载 JAVA_HOME\lib 目录中的，或通过-Xbootclasspath参数指定路径中的，且被虚拟机认可（按文件名识别，如rt.jar）的类。
  2. 扩展类加载器（Extension ClassLoader）这个类加载器是由 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。 负责加载 JAVA_HOME\lib\ext 目录中的，或通过java.ext.dirs系统变量指定路径中的类库
  3. 应用程序类加载器（Application ClassLoader）这个类加载器是由 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。 也叫做系统类加载器，可以通过getSystemClassLoader()获取，负责加载用户路径（classpath）上的类库。如果没有自定义类加载器，一般这个就是默认的类加载器。

类加载器之间的层次关系

启动类加载器 > 扩展类加载器 > 应用程序类加载器 > 自定义类加载器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class ClassLoaderTest {
	
	public static void main(String[] args) {
		
		Thread thread = new Thread();
		
		ClassLoader appClassLoader = thread.getContextClassLoader();
		ClassLoader extClassLoader = appClassLoader.getParent();
		ClassLoader booClassLoader = extClassLoader.getParent();
		
        //sun.misc.Launcher$AppClassLoader@73d16e93
		System.out.println("应用程序类加载器：" + appClassLoader);
        //sun.misc.Launcher$ExtClassLoader@15db9742
		System.out.println("扩展类加载：" + extClassLoader);
        //null
		System.out.println("启动类加载器：" + booClassLoader);
        /*
			没有获取到ExtClassLoader的父Loader，原因是Bootstrap Loader（引导类加载器）是用C语			   言实现的，找不到一个确定的返回父Loader的方式，于是就返回null。
		*/
	}
}

双亲委派模型 - 概念

类加载器之间的这种层次关系叫做双亲委派模型。
双亲委派模型要求除了顶层的启动类加载器（Bootstrap ClassLoader）外，其余的类加载器都应当有自己的父类加载器。这里的类加载器之间的父子关系一般不是以继承关系实现的，而是用组合实现的。

双亲委派模型 - 工作过程

一个类加载器接受到类加载请求，他自己不会去加载这个请求，而是将这个类加载请求委派给父类加载器，这样一层一层传送，直到到达启动类加载器（Bootstrap ClassLoader）。
只有当父类加载器无法加载这个请求时，子加载器才会尝试自己去加载。

双亲委派模型 - 好处

使得 Java 类随着它的类加载器一起具有一种带有优先级的层次关系，从而使得基础类得到统一。

双亲委派模型很好的解决了各个类加载器加载基础类的统一性问题。即越基础的类由越上层的加载器进行加载

比如： java.lang.Object 存放在 rt.jar 中，如果编写另外一个 java.lang.Object 的类并放到 ClassPath 中，程序可以编译通过。因为双亲委派模型的存在，所以在 rt.jar 中的 Object 比在 Clas sPath 中的 Object 优先级更高，因为 rt.jar 中的 Object 使用的是启动类加载器，而 ClassPath 中的 Object 使用的是应用程序类加载器。正因为 rt.jar 中的 Object 优先级更高，因为程序中所有的 Object 都是这个 Object。

双亲委派原则

  1. 可以避免重复加载，父类已经加载了，子类就不需要再次加载
  2. 更加安全，很好的解决了各个类加载器的基础类的统一问题，如果不使用该种方式，那么用户可以随意定义类加载器来加载核心api，会带来相关隐患。

双亲委派模型的代码实现

双亲委派模型的代码实现集中在java.lang.ClassLoader的loadClass()方法当中

1. 检查类是否被加载，没有则调用父类加载器的loadClass()方法；
2. 若父类加载器为空，则默认使用启动类加载器作为父加载器；
3. 若父类加载失败，抛出ClassNotFoundException 异常后，再调用自己的findClass() 方法。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//loadClass()源代码
protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    //首先检查类是否被加载
    Class c = findLoadedClass(name);
    if (c == null) {//如果没有被加载
        try {
            if (parent != null) {//存在父类
             	//则调用父类加载器的loadClass()方法；
                c = parent.loadClass(name, false);
            } else {//不存在你父类
            	//则默认使用启动类加载器作为父加载器；
                c = findBootstrapClass0(name);
            }
        } catch (ClassNotFoundException e) {
           //若父类加载失败，抛出ClassNotFoundException异常后
           //调用自身的加载功能，一般自定义类重写此方法
           c = findClass(name);
        }
    }
    if (resolve) {//是否初始化
        //再调用自己的findClass() 方法。
        resolveClass(c);
    }
    return c;
}

自定义类加载器

首先，我们定义一个待加载的普通Java类:Test.java。放在com.dream.test包下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package com.dream.test;

public class Person {
    
	private String name;

	public Person() {}

	public Person(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + "]";
	}
}

注意：

如果你是直接在当前项目里面创建，待Test.java编译后，请把Test.class文件拷贝走，再将Test.java`删除。因为如果Test.class存放在当前项目中，根据双亲委派模型可知，会通过sun.misc.Launcher$AppClassLoader类加载器加载。为了让我们自定义的类加载器加载，我们把Test.class文件放入到其他目录。

在本例中，我们Person.class文件存放的目录如下： C:\code\com\dream\test\Person.class

接下来就是自定义我们的类加载器 ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package com.dream.test;

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;

public class ClassLoadTest {

	public static void main(String[] args) throws Exception {
		
		//创建自定义类加载器对象
		MyClassLoader classLoader = new MyClassLoader("C:/code");
		//通过类的全路径获取该类的字节码文件对象
		Class<?> c = classLoader.loadClass("com.dream.test.Person");
		//创建对象
		Object obj = c.newInstance();
		
		System.out.println(obj);
		System.out.println(obj.getClass().getClassLoader());//com.dream.test.MyClassLoader@6d06d69c
	}
}

class MyClassLoader extends ClassLoader{
	
	private String classPath;

	public MyClassLoader(){}

	public MyClassLoader(String classPath) {
        this.classPath = classPath;
    }

	//将"com.dream.test.Person"转换为 Class对象	 
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		
		String replaceAll = name.replaceAll("\\.", "/");//com\dream\test\Person
		File file = new File(classPath,replaceAll + ".class");//C:\code\com\dream\test\Person.class
		
		try {
			//将文件转换为字节数组
			byte[] bytes = getClassBytes(file);
			
			//将字节数组转换为Class对象
			Class<?> c = this.defineClass(name,bytes, 0, bytes.length);
			return c;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return super.findClass(name);
	}

	//读取xxx.class文件，把该文件的内容以字节数组返回
	public byte[] getClassBytes(File file) throws Exception{
		
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		byte[] buf = new byte[1024];
		int len;
		while((len=bis.read(buf)) != -1){
			baos.write(buf, 0, len);
		}
		bis.close();
		return baos.toByteArray();
	}
}

自定义类加载器的应用场景

引入：Tomcat容器，每个WebApp有自己的ClassLoader,加载每个WebApp的ClassPath路径上的类，一旦遇到Tomcat自带的Jar包就委托给CommonClassLoader加载

  1. 加密：Java代码可以轻易的被反编译，如果你需要把自己的代码进行加密以防止反编译，可以先将编译后的代码用某种加密算法加密，类加密后就不能再用Java的ClassLoader去加载类了，这时就需要自定义ClassLoader在加载类的时候先解密类，然后再加载。
  2. 从非标准的来源加载代码：如果你的字节码是放在数据库、甚至是在云端，就可以自定义类加载器，从指定的来源加载类。

以上两种情况在实际中的综合运用：比如你的应用需要通过网络来传输 Java 类的字节码，为了安全性，这些字节码经过了加密处理。这个时候你就需要自定义类加载器来从某个网络地址上读取加密后的字节代码，接着进行解密和验证，最后定义出在Java虚拟机中运行的类。