Java虚拟机--类加载器源码

Dear 丶 2022-03-08 08:18 171阅读 0赞

# Java虚拟机–类加载器源码 #

## 类加载器源码分析 ##

下面，我们就来深入的学习下类加载器的源码，看看到底做了哪些事情？

![img][]

类加载体系

上图呈现是源码级别的类加载体系，ClassLoader是基类，所有的类加载器都需要继承它(启动类加载器除外)。

首先，我们通过上文中的测试类来举例，一点点剖析类加载的流程。

创建一个包下普通的类：com.jiaboyan.test.ObjectTest

public class ObjectTest {
    }

将此类编译，并打包处理：

jar cvf ObjectTest.jar com\jiaboyan\test\ObjectTest.class

将此jar包放入<Java\_Runtime\_Home>/lib/ext目录下；

编写测试用例：

public class JVMTest5 {
       public static void main(String[] agrs) throws ClassNotFoundException {
           Class clazz = Class.forName("com.jiaboyan.test.ObjectTest");
           System.out.println(clazz.getClassLoader());
       }
    }

使用Class.forName来加载com.jiaboyan.test.ObjectTest类，看内部具体流程。

### 类加载流程 ###

\*\*(1)\*\*进入到Class内部，可以看到实际调用了native修饰的forName0()方法。

public static Class<?> forName(String className) throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }
    
    private static native Class<?> forName0(String name, boolean initialize,
                                            ClassLoader loader,
                                            Class<?> caller) throws ClassNotFoundException;

\*\*(2)\*\*通过debug来看，在forName0()后又调用了AppClassLoader类的loadClass(String var1, boolean var2)方法。

public Class loadClass(String var1, boolean var2) throws ClassNotFoundException {
        int var3 = var1.lastIndexOf(46);
        if (var3 != -1) {
            SecurityManager var4 = System.getSecurityManager();
            if (var4 != null) {
                var4.checkPackageAccess(var1.substring(0, var3));
            }
        }
        return super.loadClass(var1, var2);
    }

在方法的末尾，调用父类中的loadClass(String name, boolean resolve)方法，也就是ClassLoader类；

\*\*(3)\*\*通过debug来看，在forName0()后又调用了ClassLoader类的loadClass(String name, boolean resolve)方法。

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException \{  
synchronized (getClassLoadingLock(name)) \{  
//先从缓存查找该class对象，找到就不用重新加载  
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) \{  
//抛出异常无需理会  
\}

if (c == null) {
                    long t1 = System.nanoTime();
                    //如果都没有找到，则通过findClass去查找并加载
                    c = findClass(name);
                    .....
                }
            }
            //是否需要在加载时进行解析
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

loadClass源码所示：当类加载请求到来时，先从缓存中查找该类对象，如果存在则直接返回，如果不存在则交给该类加载器的父类加载器去加载，倘若没有父类加载器则交给顶级启动类加载器去加载，最后仍没有找到，则使用findClass()方法去加载。

实际流程是，类加载请求进来时，this为AppClassLoader对象，判断AppClassLoader对象的parent父类加载器是否为空。根据双亲委派模型得知，此时的parent一定为ExtClassLoader对象。调用ExtClassLoader的loadClass(String name, boolean resolve)方法。

通过源码得知，ExtClassLoader继承ClassLoader抽象类，并且没有重写loadClass(String name, boolean resolve)方法。那么，此时又进入到了上面的loadClass(String name, boolean resolve)中。不过，此时的this是ExtClassLoader对象。

ExtClassLoader对象的parent父类加载器为null，调用findBootstrapClassOrNull(String name)方法，使用顶层启动类加载器去加载com.jiaboyan.test.ObjectTest类。

由于顶层启动类加载器是C++实现，我们无法直接获取到其引用，最终调用到了native修饰的findBootstrapClass(String name)方法。

由于，我们将ObjectTest.jar放在了<Java\_Runtime\_Home>/lib/ext目录下，所以顶层启动类加载器加载不到com.jiaboyan.test.ObjectTest类，继而抛出异常，返回到ExtClassLoader对象的loadClass(String name, boolean resolve)方法中来。

\*\*(4)\*\*接下来，继续调用findClass(name)方法。

protected Class<?> findClass(final String name) throws ClassNotFoundException{
        try {
            return AccessController.doPrivileged(
                new PrivilegedExceptionAction<Class>() {
                    public Class run() throws ClassNotFoundException {
                        String path = name.replace('.', '/').concat(".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 {
                            throw new ClassNotFoundException(name);
                        }
                    }
                }, acc);
        } catch (java.security.PrivilegedActionException pae) {
            throw (ClassNotFoundException) pae.getException();
        }
    }

由于现在的this为ExtClassLoader对象，所以我们调用ExtClassLoader对象的findClass(final String name)方法。通过查看源码发现，ExtClassLoader并没有findClass方法，不过再其父类URLClassLoader中有实现(代码如上)。

\*\*(5)\*\*调用defineClass(String name, Resource res)方法。

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);
            Manifest man = res.getManifest();
            if (getAndVerifyPackage(pkgname, man, url) == null) {
                try {
                    if (man != null) {
                        definePackage(pkgname, man, url);
                    } else {
                        definePackage(pkgname, null, null, null, null, null, null, null);
                    }
                } catch (IllegalArgumentException iae) {
                    if (getAndVerifyPackage(pkgname, man, url) == null) {
                        throw new AssertionError("Cannot find package " + pkgname);
                    }
                }
            }
        }
        java.nio.ByteBuffer bb = res.getByteBuffer();
        if (bb != null) {
            //获取资源内的字节流数组：
            CodeSigner[] signers = res.getCodeSigners();
            CodeSource cs = new CodeSource(url, signers);
            sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0);
            return defineClass(name, bb, cs);
        } else {
            //获取资源内的字节流数组：
            byte[] b = res.getBytes();
            CodeSigner[] signers = res.getCodeSigners();
            CodeSource cs = new CodeSource(url, signers);
            sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0);
            return defineClass(name, b, 0, b.length, cs);
        }
    }

defineClass(String name, Resource res)方法是用来将byte字节流解析成JVM能够识别的Class对象，通过这个方法不仅能够通过class文件实例化class对象，也可以通过其他方式实例化class对象，如通过网络接收一个类的字节码，然后转换为byte字节流创建对应的Class对象。

最后调用了defineClass(String name, java.nio.ByteBuffer b,CodeSource cs)方法，具体内部细节笔者不在详细陈序，需要说明的是：Class对象依旧使用了native修饰的方法来完成，内部细节无从得知。

private native Class defineClass2(String name, java.nio.ByteBuffer b,
                                      int off, int len, ProtectionDomain pd,
                                      String source);

(6)至此ExtClassLoader对象的加载阶段就此结束，Class对象返回。当返回到AppClassLoader对象中时，c并不为null，所以无需再次调用c = findClass(name)方法，整个类加载完成。

通过上述源码可知，当我们自己定义一个类加载器时候，无需重写loadClass()方法，直接重写自定义的findClass(String name)即可。父类加载器加载失败时候，最终都会走到findClass(String name)中来。

说完了类加载主体流程，接下来我们来研究一点细节的东西！！！！

此时，将文章拉回上面源码体系截图中，我们来看看SecureClassLoader、URLClassLoader类起到了哪些作用。

### SecureClassLoader ###

SercureClassLoader继承ClassLoader，扩展了ClassLoader类的功能，增加对代码源和权限定义类的验证。

### URLClassLoader ###

URLClassLoader继承SercureClassLoader，实现了ClassLoader中定义的方法，例如：findClass()、findResource()等。

在URLClassLoader中有一个成员变量ucp–URLClassPath对象，URLClassPath的功能是通过传入的路径信息获取要加载的字节码，字节码可以是在.class文件中、可以是在.jar包中，也可以是在网络中。

public URLClassLoader(URL[] urls) {
        super();
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkCreateClassLoader();
        }
        ucp = new URLClassPath(urls);
        this.acc = AccessController.getContext();
    }

在URLClassPath构造中，需要传入URL\[\]数组，通过这个URL\[\]数组中所指定的位置信息，去加载对应的文件。在URLClassPath内部会根据传递的路径是文件地址、jar包地址还是网络地址来进行判断，来生成对应Loader。

public URLClassPath(URL[] var1, URLStreamHandlerFactory var2) {
        this.path = new ArrayList();
        this.urls = new Stack();
        this.loaders = new ArrayList();
        this.lmap = new HashMap();
        this.closed = false;
    
        for(int var3 = 0; var3 < var1.length; ++var3) {
            this.path.add(var1[var3]);
        }
    
        this.push(var1);
        if (var2 != null) {
            this.jarHandler = var2.createURLStreamHandler("jar");
        }

根据路径的不同，来生成不同的Loader:

private URLClassPath.Loader getLoader(final URL var1) throws IOException {
        try {
            return (URLClassPath.Loader)AccessController.doPrivileged(new PrivilegedExceptionAction<URLClassPath.Loader>() {
                public URLClassPath.Loader run() throws IOException {
                    String var1x = var1.getFile();
                    if (var1x != null && var1x.endsWith("/")) {
                        return (URLClassPath.Loader)("file".equals(var1.getProtocol()) ? new URLClassPath.FileLoader(var1) : new URLClassPath.Loader(var1));
                    } else {
                        return new URLClassPath.JarLoader(var1, URLClassPath.this.jarHandler, URLClassPath.this.lmap);
                    }
                }
            });
        } catch (PrivilegedActionException var3) {
            throw (IOException)var3.getException();
        }
    }

[img]: /images/20220308/d817570bb4564187be6a82c1ecf64a44.png