Java类加载机制源码分析

Java代码首先要编译成class文件字节码,在运行时通过JIT(即时编译器)编译成本地机器码,最后由ClassLoader将其加载解析成Class对象到内存中。通过ClassLoader的loadClass方法的源码加深对Java类加载机制的理解。


1. ClassLoader加载机制简述

Java的类加载遵循父类优先的原则,也就是说ClassLoader是一个有层级的树形组合体系,并且一个ClassLoader要加载一个类,首先逐层向上检查是否有加载器加载过该类,如果有,将结果逐层返回到下级。如果没有,继续检查直到有一层ClassLoader返回没有加载并且它不应该加载,那么该层的下一层就可以加载该类。


PS:父类优先的方式也不是万能的,在JavaEE Web应用程序中,也会使用子女优先加载的方式;


1.1 JVM提供3层基本的类加载平台

BootstrapClassLoader:加载JVM自身需要的类,注意在Hotspot JVM中它严格来说不是JVM类加载体系中的,它并不遵循上述机制,也不是下面ExtClassLoader的父类加载器;

ExtClassLoader:加载特定的类:System.getProperty("java.ext.dirs");也就是JRE/LIB/EXT目录下的类,加载的是sun公司的一些扩展包,它是AppClassLoader的父类加载器;

AppClassLoader:加载System.getProperty("java.class.path");就是classpath,看到这个你可能已经知道eclipse项目下.classpath的作用了,就是告诉AppClassLoader这些类由它加载;

继承自URLClassLoader的自定义类加载器,通过调用getSystemClassLoader获取自己的父加载器(AppClassLoader);


ClassLoader的类层次结构:



图中的AppClassLoader和ExtClassLoader是Launcher的内部类;

到现在,我们可以也可以看出Java的ClassLoader使用了职责链设计模式,父优先加载,一定程度上保证了程序安全(防止恶意代码替换JSE核心类)。


1.2 JVM加载Class文件到内存的方式:

一是隐式加载:继承或引用某个类时,有JVM负责加载;

二是显式加载:在代码中调用loadClass(),Class.forName,ClassLoader的findClass方法等,显式加载中也可能包含隐式加载;


2. ClassLoader的重要方法:

findClass:主要由URLClassLoader实现,根据URLClassPath去指定地方查找class文件;取得要加载class文件的字节流;

defineCLass:可以将字节流解析成Class对象,该Class对象并未进行resolve;

resolveClass:对Class对象进行Link,载入引用类(超类,接口字段,方法签名,方法中的本地变量);

loadClass:采用默认的加载逻辑根据类名加载一个类,返回Class对象,调用前面3个方法实现;


3. 加载class文件的过程:

3.1 加载字节码到内存:findClass和defineClass方法

首先来看看URLClassLoader中的findClass方法,因为加载的第一步,找到并获取指定class文件的字节流;
protected Class<?> findClass(final String name)
            throws ClassNotFoundException
    {
        final Class<?> result;
        try {
            //获取特权,确保有权限可以读取到资源,这里
            result = AccessController.doPrivileged(
                    new PrivilegedExceptionAction<Class<?>>() {
                        public Class<?> run() throws ClassNotFoundException {
                            //将完整的类名转换成文件路径格式
                            String path = name.replace('.', '/').concat(".class");
                            //在指定的URLPath中获取对应的class文件资源
                            Resource res = ucp.getResource(path, false);
                            if (res != null) {
                                try {
                                    //获取成功将资源传入,最终获取未解析的Class对象
                                    return defineClass(name, res);
                                } catch (IOException e) {
                                    //不能成功读取文件内容
                                    throw new ClassNotFoundException(name, e);
                                }
                            } else {
                                //不能获取资源
                                return null;
                            }
                        }
                    }, acc);
        } catch (java.security.PrivilegedActionException pae) {
            //因为要在特权操作中抛出ClassNotFoundException,使用了PrivilegedExceptionAction回调
            //它会将异常包装,这里要解除包装
            throw (ClassNotFoundException) pae.getException();
        }
        if (result == null) {
            throw new ClassNotFoundException(name);
        }
        return result;
    }

findClass方法的作用就是找到并借助defineClass方法返回Class对象(未解析),它获取特权权限去读取资源(Java安全模型对不同的代码是区分Domain的,不同的域(比如不同的项目的代码)可能对其他域的代码限制了访问自身资源的权限,具体可以参看 http://www.ibm.com/developerworks/cn/java/j-lo-javasecurity/),并保证了在不同情况下可以正确的抛出ClassNotFoundException;

接下来看看findClass中使用的defineClass方法:
private Class<?> defineClass(String name, Resource res) throws IOException {
        long t0 = System.nanoTime();
        int i = name.lastIndexOf('.');
        URL url = res.getCodeSourceURL();
        //首先加载包
        if (i != -1) {
            String pkgname = name.substring(0, i);
            // Check if package already loaded.
            Manifest man = res.getManifest();
            definePackageInternal(pkgname, man, url);
        }
        // Now read the class bytes and define the class
        //使用nio,获取字节缓冲区
        java.nio.ByteBuffer bb = res.getByteBuffer();
        if (bb != null) {
            // Use (direct) ByteBuffer:
            CodeSigner[] signers = res.getCodeSigners();
            CodeSource cs = new CodeSource(url, signers);
            sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0);
            return defineClass(name, bb, cs);
        } else {
            //获取不到缓冲区,直接InputStream获取字节数组
            byte[] b = res.getBytes();
            // must read certificates AFTER reading bytes.
            CodeSigner[] signers = res.getCodeSigners();
            CodeSource cs = new CodeSource(url, signers);
            sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0);
            return defineClass(name, b, 0, b.length, cs);
        }
    }

在这个方法中,我们可以看到对于class文件的读取策略,其中CodeSigner和CodeSource分别是代码签名和代码源,它们组合使用与前面提及的保护域机制( ProtectionDomain)当中,可见Java中类加载机制和安全模型是密不可分的。

3.2 验证和解析:defineClass方法和resovleClass方法:

defineClass首先进行:
(1)字节码验证;
(2)类准备:准备类中每个字段、方法和实现接口所需的数据结构
protected final Class<?> defineClass(String name, byte[] b, int off, int len,
                                         ProtectionDomain protectionDomain)
            throws ClassFormatError
    {
        //首先检查类名;阻止加载“java.”开头包内的类(应有BootStrapLoader加载);
        //确保同一个包内的Class拥有相同的证书
        protectionDomain = preDefineClass(name, protectionDomain);
        //根据CodeSource获取一个URL的字符串表示
        String source = defineClassSourceLocation(protectionDomain);
        //字节码验证;类准备(准备字段,方法,实现接口所必需的数据结构);
        Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);
        //通过证书为该类设置签名
        postDefineClass(c, protectionDomain);
        return c;
    }

(3)解析:resolveClass方法,直接通过一个native方法实现
进行LINK,装入引用类,如超类,接口,字段,方法中使用的本地变量。

3.3 显式加载时的过程:

调用this.getClass().getClassLoader().loadClass("className");时的过程:

首先看看URLClassLoader中的loadClass方法:

protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
    {
        //该getClassLoadingLock获取同步锁,该锁用并发Map保存(享元模式)
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    // 这里体现了类加载机制中的父优先的查找机制
                    // 通过上滤直到parent为null
                    // 这时再去BootstrapClassLoader中查找,在运行用户程序时,这一步一般都是null
                    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);

                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            //解析连接类
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

反映了JVM类加载机制的过程为:加载一个新类,逐层上滤检查父加载器,直到顶层(parent==null),再去BootStrapClassLoader中查找,如果返回null,就要调用findClass,resolveCass(需要的话);

3.4 初始化Class对象:

类的静态字段,静态初始化器会按顺序赋值/执行;

上面的过程概括一下:(1)加载class文件字节码到内存——>(2)将字节码转换成未Link的Class对象(安全验证/字节码验证/类准备)——>(3)resolveClass方法Link
——>(4)类初始化;

4. 小结

本篇总结了一下Java类加载机制的机制和过程,并从源码角度加以分析。在分析源码的过程也看到了Java中的安全模型的应用,以及并发控制(findClass中的lock并发Map)







评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值