JVM类加载机制理解

电玩女神 2022-04-13 03:44 269阅读 0赞

from：[http://blog.abreaking.com][http_blog.abreaking.com]

# 概述 #

我们知道，当编写完一个java文件后，使用javac命令可以将该java文件编译成java字节码文件，即.class的文件。class文件存储者该类的各种描述信息，而后我们可以使用java命令启动java虚拟机，虚拟机把描述类的数据从class文件中加载到内存，并对数据进行校验、解析及初始化，最终形成可被虚拟机直接使用的Java类型。

从字节码文件到可使用的Java类型 这样的一个流程，就是类的加载、连接、初始化的过程。

![dc58ad20ec8c4c51b4f604b9aacc8b16.png][]

**类的加载：**就是将类的.class文件中的二进制数据读入到内存中去，将其放在运行时数据区的**方法区**中；然后在堆中创建一个Java.lang.Class对象，用来封装类在方法区中的数据结构。可以认为，类加载的最终的成品是位于堆中Class对象，该对象封装了类在方法区中的数据结构，并提供访问方法区中数据结构的接口。

**类的连接**：主要为3部分：

1.  验证：即确保被加载类的正确性。
2.  准备：为类的**静态变量**分配内存，并初始化默认值。
3.  把类中符号引用转换为符号引用。

**类的初始化**：为类的静态变量赋予正确的初始值。

# 类的加载 #

## JVM类加载器 ##

类加载class文件，不管这个文件是正常本地文件、还是jar包里面的文件，还是位于其他的位置。JVM自带三种类加载器：

1.  根类加载器（Boostrap ClassLoader）：负责加载虚拟机的核心类，如java.lang包下面的类。这个类加载器的实现依赖底层操作系统;
2.  扩展类加载器（Extension ClassLoader）：它的父类加载器是根类加载器，它从java.ext.dirs系统属性所指定的目录中加载类库，或者从jdk的安装目录下的：jre\\lib\\ext子目录下加载类库。我们可以将我们的jar包放在该目录下，就会被该类加载器加载。扩展类加载器是java.lang.ClassLoader的子类；
3.  系统类加载器（System ClassLoader）：也叫做应用类加载器，父类加载器是扩展类加载器。就是加载classpath路径下指定的类或者jar包。

注意，以上所说的父类加载器并不是继承，而是包装，即在构造方法中包装父类加载器。当然，也可以自定义类加载器。

## 类加载机制 ##

类的加载机制是父类委托机制，如下。除根类加载器外，其余类加载器有且只有一个父类加载器。

当某个class文件被底层的类加载器加载时，该类加载器并不会即刻对该字节码文件进行加载，而是先委托给父类加载器，父类再委托给父类，直到根类加载器，如果根类加载器能够加载该类，那么就加载，否则就让其子类加载器加载，以此类推，在某一级中该类被加载了，那么就表示类加载完成，类加载完毕的数据信息会告知其子类加载器（准确的说，因为子类加载器包装了父类，那么就拥有父类的加载信息），该级的类加载器就称之为该定义类的加载器。

如果仍然没有类加载可以加载该类，那么就会抛出ClassNotFoundException异常。

![dacfc479393d4d0eb28a07895507b026.png][]

在java.lang.ClassLoader\#loadClass(java.lang.String, boolean)方法中，

Class<?> c = findLoadedClass(name);
        if (c == null) {
    	long t0 = System.nanoTime();
    	try {
    	    if (parent != null) {
                    //这里，如果父类加载器不为空，那么就有父类加载器去加载
    		c = parent.loadClass(name, false);
    	    } else {
                   //没父类加载器，那么就是Bootstarp ClassLoader
    		c = findBootstrapClassOrNull(name);
    	    }
    	} catch (ClassNotFoundException e) {
    	    // ClassNotFoundException thrown if class not found
    	    // from the non-null parent class loader
    	}
    ......

## 自定义类加载器 ##

自定义类加载器需要继承ClassLoader这个类，可复写loadClass或findClass方法，loadClass这个方法一般没必要复写，ClassLoader已经指定了父类委托机制的算法，所以，我们复写findClass这个方法。如：

public class MyClassLoader extends ClassLoader {
    
        //假设在这个目录下放着一个class文件
        String fileDir = "e:\\classloader\\";
    
        public MyClassLoader(){
        }
    
        //可指定一个父类加载器，进而测试父类委托机制
        public MyClassLoader(ClassLoader parent){
            super(parent);
        }
    
        @Override
        protected Class<?> findClass(String className) throws ClassNotFoundException{
            FileInputStream inputStream = null;
            try {
                String name = className;  //类名，一般就是类的全限定名
                className = className.replace(".","\\");
                className += ".class";
                //找到这个类的class文件，读取为输入流
                inputStream = new FileInputStream(new File(fileDir+className));
                //将class文件的二进制数据保存到字节数组中
                byte[] bytes = new byte[inputStream.available()];
                inputStream.read(bytes);
                //调用ClassLoader的defineClass方法获取到该类的class对象，defineClass方法由本地(native)方法实现
                Class<?> aClass = defineClass(name, bytes, 0, bytes.length);
                return aClass;
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                if(inputStream!=null){
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            throw new ClassNotFoundException("没有这个类");
        }
    }

以上就自定义了一个类加载器。我在fileDir目录下写了一个java类，并用javac命令编译成了class文件。

package com.foo.test;
    public class User
    {}

使用以上定义的类加载器去加载编译后的class文件。

@Test
    public void test01() throws Exception {
             String className = "com.foo.test.User";
            MyClassLoader classLoader = new MyClassLoader();
            //使用自定义类加载器去加载这个类
            Class<?> clazz = classLoader.loadClass(className);
            System.out.println("类名："+clazz.getName());
            System.out.println("类加载器："+clazz.getClassLoader());
        }

结果如下，说明能够加载到该类：

![f54b7838311a47be8ba42317c0eb8fe1.png][]

我们再验证下父类委托机制，创建两个类加载器：classLoader1，classLoader2。classLoader2包装了classLoader1，那么classLoader1就是classLoader2的父类加载器，使用classLoader2去加载User的class文件。

@Test
    public void test02()throws Exception {
    	String className = "com.foo.test.User";
    	MyClassLoader classLoader1 = new MyClassLoader();
    	//classLoader2包装了classLoader1，那么classLoader1就是classLoader2的父类加载器
    	MyClassLoader classLoader2 = new MyClassLoader(classLoader1);
    	//使用classLoader2去加载该类
    	Class<?> clazz = classLoader2.loadClass(className);
    	System.out.println("classLoader1:"+classLoader1);
    	System.out.println("classLoader2:"+classLoader2);
    	System.out.println("该类的定义类加载器为："+clazz.getClassLoader());
    }

结果为：

![9fe67af97fb54664afb46424d53b5bc7.png][]

可见，尽管用了classLoader2去加载该类，该类确是被classLoader1加载了。这就是因为classLoader1是classLoader2的父类加载器，classLoader2会先委托为classLoader1尝试去加载该类，如果classLoader1还有父类，还会委托给其父类，其父类不能加载，才回到classLoader1去加载，此刻classLoader1能够加载该类，那么该类就会被classLoader1加载完毕了。

## 父委托机制 ##

类加载的父委托机制的优点就是能够提高软件系统的安全性，防止同一个字节码文件被多次的加载。

我们引用同包目录的下的不同类，之所以不用再写import ...，不仅是他们是在同一个包下面，并且他们都是被同一个类加载器加载的。如果仅同包，而被不同类加载器加载，那么此刻同包类之间是相互引用不到的。

每个类加载器都由自己的命令空间，命名空间由该加载器及所有的父类加载器所加载的类组成。同一个命名空间内的类是相互可见的，即可以相互import的。子类的命令空间包括了所有的父类空间，所以前面所说子类加载器加载的类能看到父类加载器的类，如系统类加载器能看到启动类加载器中的所有的类。

当然了，没有这种父子关系的两个类加载器，他们之间的命令空间是相互独立的，也就是不可见的。

[http_blog.abreaking.com]: http://blog.abreaking.com
[dc58ad20ec8c4c51b4f604b9aacc8b16.png]: /images/20220413/7e646a755e8949a585264ee95d0422c7.png
[dacfc479393d4d0eb28a07895507b026.png]: /images/20220413/a39ab3f4f8044a898e437a6e80130f5d.png
[f54b7838311a47be8ba42317c0eb8fe1.png]: /images/20220413/414992e867224804a21497d6ab936ecd.png
[9fe67af97fb54664afb46424d53b5bc7.png]: /images/20220413/3be9d8d78c2f446fbe34622847d9f775.png