Java类加载机制&类加载器

发布于 2019-07-31  127 次阅读


类加载过程

类从被加载到虚拟机内存中开始,到卸载出内存为止,它的整个生命周期包括:加载、验证、准备、解析、初始化、使用和卸载七个阶段。
其中类加载的过程包括了加载、验证、准备、解析、初始化五个阶段。在这五个阶段中,加载、验证、准备和初始化这四个阶段发生的顺序是确定的,而解析阶段则不一定,它在某些情况下可以在初始化阶段之后开始,这是为了支持 Java 语言的运行时绑定(也成为动态绑定或晚期绑定)。

类加载器作用

类加载器用于实现类的加载过程。对于任何一个类,都与要由它的类加载器和这个类本身一同确立在Java虚拟机中的唯一性,每一个类加载器都拥有一个唯一个类名称空间。
换言之,比较两个类是否“相等”,只有在两个类是由同一个类加载器的前提之下才有意义,否则,即使这两个类来源于同一个class文件,只要加载它的类加载器不同,那这两个类必定不相等。这里所指的“相等”包括代表类的Class对象的equal()、isAssignableFrom()、isInstance()方法及instanceof关键字返回的结果。

  • 不同类加载器对instanceof关键字运算的结果的影响
    下面的代码自定义了类加载器,它可以加载和自己在同一路径下的class文件。我们使用其加载ClassLoaderTest类,然后实例化这个对象的类。并用instanceof关键字将其和由系统应用程序类加载器加载的ClassLoaderTest类比较。
import java.io.IOException;
import java.io.InputStream;

/**
 * Created by HAPPY on 2019/7/31
 */
public class ClassLoaderTest {

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        ClassLoader myLoader = new ClassLoader() {
            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                try {
                    String filename = name.substring(name.lastIndexOf(".") + 1) + ".class";
                    InputStream inputStream = getClass().getResourceAsStream(filename);
                    if (inputStream == null) {
                        return super.loadClass(name);
                    }
                    byte[] b = new byte[inputStream.available()];
                    inputStream.read(b);
                    return defineClass(name, b, 0, b.length);
                } catch (IOException e) {
                    //e.printStackTrace();
                    throw new ClassNotFoundException(name);
                }
            }
        };
        Object obj = myLoader.loadClass("ClassLoaderTest").newInstance();
        System.out.println(obj.getClass());
        System.out.println(obj instanceof ClassLoaderTest);
    }
}

运行结果

class ClassLoaderTest
false

从第一个结果看出,这个对象确实是从ClassLoaderTest实例化出来的对象。
由第二个结果,由于虚拟机中存在两个ClassLoaderTest类,一个是由系统应用程序类加载器加载的,另一个时我们自定义的类加载器加载的,虽然都来自同一个class文件,但是确实两个独立的类,做对象所属类型检查的时候返回flase.

Java虚拟机类加载器分类

从Java虚拟机的角度来讲,只存在两种不同的类加载器:一种是启动类加载器(Bootstrap ClassLoader),这个类加载器由C++实现,是虚拟机自身的一部分;另一种就是其他的类加载器,这些类加载器由Java语言实现,独立于虚拟机之外,而且全部继承于抽象类java.lang.ClassLoader

(注意,启动类加载器在HotSpt虚拟机中由C++实现,而MRP,Maxine等整个虚拟机都是由Java实现的,启动类加载器自然也由Java实现。但是,有些高性能虚拟机在启动类加载器的关键方法的实现仍然是使用JNI回调到C(不是C++)的实现上,这个Bootstrap ClassLoader的实例无法被用户获取到)
但从Java开发人员的角度来讲,类加载器还能划分的更细致些,如下:

Bootstrap ClassLoader/启动类加载器

主要负责/lib目录下的核心 api 或 -Xbootclasspath 选项指定的jar包加载到虚拟机内存。其中,这些jar包必须是虚拟机识别的,而虚拟机通过文件名识别,例如rt.jar。
启动类加载器无法被Java程序直接引用,用户在编写自定义类加载器的时候,如果需要把请求委托给Bootstrap ClassLoader,直接使用null代替即可。

Extension ClassLoader/扩展类加载器

主要负责加载/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包。开发者可以直接使用拓展类加载器。
这个类加载器由sun.misc.Launcher$AppClassLoader实现。

System ClassLoader/系统类加载器(AppClassLoader/应用程序类加载器)

应用程序类加载器其实是ClassLoader中的getSystemClassLoader()方法的返回值,所以一般也称其为系统类加载器.
其主要负责加载java -classpath/-Djava.class.path所指的目录下的类与jar包。

User Custom ClassLoader/用户自定义类加载器(java.lang.ClassLoader的子类)

在程序运行期间, 通过java.lang.ClassLoader的子类动态加载class文件, 体现java动态实时类装入特性。

双亲委派模型

机制介绍

如果一个类加载器收到了一个类加载请求,它首先不会自己去加载这个类,而是把这个请求委托给父类加载器去完成,每一个层次的类加载器都是如此,因此所有的加载请求最终都应该传送到顶层的启动类加载器中,只有当父类加载器反馈自己无法完成加载请求(它管理的范围之中没有这个类)时,子加载器才会尝试着自己去加载。

优点

  • 避免重复加载,当父亲已经加载了该类的时候,就没有必要子ClassLoader再加载一次。
  • Java类随着它的类加载器一起具备了一种带有优先级的层次关系,例如java.lang.Object存放在rt.jar之中,无论那个类加载器要加载这个类,最终都是委托给启动类加载器进行加载,因此Object类在程序的各种类加载器环境中都是同一个类,相反,如果没有双亲委托模型,由各个类加载器去完成的话,如果用户自己写一个名为java.lang.Object的类,并放在classpath中,应用程序中可能会出现多个不同的Object类,java类型体系中最基本安全行为也就无法保证。

实现

实现双亲委派模型的代码集中于java.lang.ClassLoader的loadClass()方法中。先检查是否已经被加载过,若没有加载则调用父类加载器的loadClass()方法,若父加载器为空则默认使用启动类加载器作为父加载器。如果父加载失败,则抛出ClassNotFoundException异常后,再调用自己的findClass()方法进行加载。

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

注意,双亲委派模型是Java设计者推荐给开发者的类加载器的实现方式,并不是强制规定的。
大多数的类加载器都遵循这个模型,但是JDK中也有较大规模破坏双亲模型的情况,例如线程上下文类加载器(Thread Context ClassLoader)的出现。

类加载器的几个重要方法

类加载器均是继承自java.lang.ClassLoader抽象类。下面简要看一下java.lang.ClassLoader中几个最重要的方法:

loadClass

loadClass: 此方法负责加载指定名字的类,首先会从已加载的类中去寻找,如果没有找到;从parent ClassLoader[ExtClassLoader]中加载;如果没有加载到,则从Bootstrap ClassLoader中尝试加载(findBootstrapClassOrNull方法), 如果还是加载失败,则抛出异常ClassNotFoundException, 在调用自己的findClass方法进行加载。如果要改变类的加载顺序可以覆盖此方法;如果加载顺序相同,则可以通过覆盖findClass方法来做特殊处理,例如:解密,固定路径寻找等。当通过整个寻找类的过程仍然未获取Class对象,则抛出ClassNotFoundException异常。如果类需要resolve,在调用resolveClass进行链接。

findLoadedClass

findLoadedClass:此方法负责从当前ClassLoader实例对象的缓存中寻找已加载的类,调用的为native方法。

protected final Class<?> findLoadedClass(String name) {
if (!checkName(name))
    return null;
return findLoadedClass0(name);
}
private native final Class findLoadedClass0(String name);

findClass

findClass: 此方法直接抛出ClassNotFoundException异常,因此要通过覆盖loadClass或此方法来以自定义的方式加载相应的类。

protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}

defineClass

defineClass: 此方法负责将二进制字节流转换为Class对象,这个方法对于自定义类加载器而言非常重要。如果二进制的字节码的格式不符合jvm class文件格式规范,则抛出ClassFormatError异常;如果生成的类名和二进制字节码不同,则抛出NoClassDefFoundError;如果加载的class是受保护的、采用不同签名的,或者类名是以java.开头的,则抛出SecurityException异常。

protected final Class<?> defineClass(String name, byte[] b, int off, int len,ProtectionDomain protectionDomain)throws ClassFormatError
{
     return defineClassCond(name, b, off, len, protectionDomain, true);
}

// Private method w/ an extra argument for skipping class verification
private final Class<?> defineClassCond(String name,byte[] b, int off, int len,ProtectionDomain protectionDomain,boolean verify)throws ClassFormatError
{
    protectionDomain = preDefineClass(name, protectionDomain);

    Class c = null;
        String source = defineClassSourceLocation(protectionDomain);

    try {
        c = defineClass1(name, b, off, len, protectionDomain, source,verify);
    } catch (ClassFormatError cfe) {
        c = defineTransformedClass(name, b, off, len, protectionDomain, cfe,source, verify);
    }

    postDefineClass(c, protectionDomain);
    return c;
}

resolveClass

resolveClass: 此方法负责完成Class对象的链接,如果链接过,则直接返回。

线程上下文加载器

这个加载器解决了基础类想调用回用户代码的问题。

如果不做任何的设置,Java 应用的线程的上下文类加载器默认就是系统上下文类加载器。

java动态载入class的两种方式

implicit

隐式方式,即利用实例化才载入的特性来动态载入class

explicit

显式方式,又分两种方式:

  • java.lang.ClassforName()方法
  • java.lang.ClassLoaderloadClass()方法

常见异常

  • ClassNotFoundException 这是最常见的异常,产生这个异常的原因为在当前的ClassLoader 中加载类时,未找到类文件,
  • NoClassDefFoundError 这个异常是因为 加载到的类中引用到的另外类不存在,例如要加载A,而A中盗用了B,B不存在或当前的ClassLoader无法加载B,就会抛出这个异常。
  • LinkageError 该异常在自定义ClassLoader的情况下更容易出现,主要原因是此类已经在ClassLoader加载过了,重复的加载会造成该异常。