页面加载中...

JVM类加载机制理解

| Java | 0 条评论 | 735浏览

概述

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

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

类的加载:就是将类的.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的安装目录下的:jrelibext子目录下加载类库。我们可以将我们的jar包放在该目录下,就会被该类加载器加载。扩展类加载器是java.lang.ClassLoader的子类;
  3. 系统类加载器(System ClassLoader):也叫做应用类加载器,父类加载器是扩展类加载器。就是加载classpath路径下指定的类或者jar包。

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

类加载机制

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

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

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

在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 ClassLoaderc = 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());
    }

结果如下,说明能够加载到该类:

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

@Testpublic 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());}

结果为:

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

父委托机制

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

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

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

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

 

发表评论

最新评论

    来第一个评论吧!