深入分析 Java 类加载器原理

实验中的 ClassLoaderTest 类就是一个简单的定义了两个 field 的 Class。如下图所示

最终的打印结果如下

PS: 实验类（ClassLoaderTest）最好不要放在 IDE 的工程目录内，因为 IDE 在 run 的时候会先将工程中的所有类都加载到内存，这样一来这个类就不是自定义类加载器加载的了，而是 AppClassLoader 加载的。

3.3 类加载器对“相等”判断的影响

3.3.1 对 Object.equals()的影响

还是上面那个自定义类加载器

修改 MyClassLoader 代码

3.3.2 对 instanceof 的影响
修改 TestClassLoader，增加 main 方法来实验，修改后的 TestClassLoader 如下：
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

/**
 * 自定义ClassLoader
 * 功能：可自定义class文件的扫描路径
 * @author zhiminxu
 */
// 继承ClassLoader，获取基础功能
public class TestClassLoader extends ClassLoader {

    public static void main(String[] args) throws ClassNotFoundException {
        TestClassLoader testClassLoader = new TestClassLoader("/Users/zhiminxu/developer/classloader");
        Object obj = testClassLoader.loadClass("ClassLoaderTest");
        // obj是testClassLoader加载的，ClassLoaderTest是AppClassLoader加载的，所以这里打印:false
        System.out.println(obj instanceof ClassLoaderTest);
    }

    // 自定义的class扫描路径
    private String classPath;

    public TestClassLoader(String classPath) {
        this.classPath = classPath;
    }

    // 覆写ClassLoader的findClass方法
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // getDate方法会根据自定义的路径扫描class，并返回class的字节
        byte[] classData = getDate(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            // 生成class实例
            return defineClass(name, classData, 0, classData.length);
        }
    }


    private byte[] getDate(String name) {
        // 拼接目标class文件路径
        String path = classPath + File.separatorChar + name.replace('.', File.separatorChar) + ".class";
        try {
            InputStream is = new FileInputStream(path);
            ByteArrayOutputStream stream = new ByteArrayOutputStream();
            byte[] buffer = new byte[2048];
            int num = 0;
            while ((num = is.read(buffer)) != -1) {
                stream.write(buffer, 0 ,num);
            }
            return stream.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

打印结果：
false
其他的还会影响 Class 的 isAssignableFrom()方法和 isInstance()方法，原因与上面的相同。
3.3.3 另外的说明
不要尝试自定义 java.lang 包，并尝试用加载器去加载他们。像下面这样

这么干的话，会直接抛出一个异常

这个异常是在调用 defineClass 的校验过程抛出的，源码如下
4 跟 ClassLoader 相关的几个异常
想知道如下几个异常在什么情况下抛出，其实只需要在 ClassLoader 中找到哪里会抛出他，然后在看下相关逻辑即可。
4.1 ClassNotFoundException
这个异常，相信大家经常遇到。
那么，到底啥原因导致抛出这个异常呢？
看一下 ClassLoader 的源码，在 JVM 调用 loadClassInternal 的方法中，就会抛出这个异常。
其声明如下：
// This method is invoked by the virtual machine to load a class.
private Class<?> loadClassInternal(String name)
    throws ClassNotFoundException
{
    // For backward compatibility, explicitly lock on 'this' when
    // the current class loader is not parallel capable.
    if (parallelLockMap == null) {
        synchronized (this) {
             return loadClass(name);
        }
    } else {
        return loadClass(name);
    }
}

这里面 loadClass 方法会抛出这个异常，再来看 loadClass 方法
public Class<?> loadClass(String name) throws ClassNotFoundException {
    return loadClass(name, false);
}

调用了重写的 loadClass 方法
protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        // First, check if the class has already been loaded
        // 查看findLoadedClass的声明，没有抛出这个异常
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                if (parent != null) {
                    // 这里会抛，但同样是调loadClass方法，无需关注
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // catch住没有抛，因为要在下面尝试自己获取class
                // 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;
    }
}

再来看 findClass 方法
/**
 * Finds the class with the specified <a href="#name">binary name</a>.
 * This method should be overridden by class loader implementations that
 * follow the delegation model for loading classes, and will be invoked by
 * the {@link #loadClass <tt>loadClass</tt>} method after checking the
 * parent class loader for the requested class.  The default implementation
 * throws a <tt>ClassNotFoundException</tt>.
 *
 * @param  name
 *         The <a href="#name">binary name</a> of the class
 *
 * @return  The resulting <tt>Class</tt> object
 *
 * @throws  ClassNotFoundException
 *          If the class could not be found
 *
 * @since  1.2
 */
protected Class<?> findClass(String name) throws ClassNotFoundException {
    throw new ClassNotFoundException(name);
}

果然这里抛出的，注释中抛出这个异常的原因是说：当这个 class 无法被找到时抛出。
这也就是为什么在上面自定义的类加载器中，覆写 findClass 方法时，如果没有找到 class 要抛出这个异常的原因。
至此，这个异常抛出的原因就明确了：在双亲委派模型的所有相关类加载器中，目标类在每个类加载器的扫描路径中都不存在时，会抛出这个异常。
4.2 NoClassDefFoundError
这也是个经常会碰到的异常，而且不熟悉的同学可能经常搞不清楚什么时候抛出 ClassNotFoundException，什么时候抛出 NoClassDefFoundError。
我们还是到 ClassLoader 中搜一下这个异常，可以发现在 defineClass 方法中可能抛出这个异常，defineClass 方法源码如下：

这个校验的源码如下
// true if the name is null or has the potential to be a valid binary name
private boolean checkName(String name) {
    if ((name == null) || (name.length() == 0))
        return true;
    if ((name.indexOf('/') != -1)
        || (!VM.allowArraySyntax() && (name.charAt(0) == '[')))
        return false;
    return true;
}

所以，这个异常抛出的原因是：类名校验未通过。
但这个异常其实不止在 ClassLoader 中抛出，其他地方，例如框架中，web 容器中都有可能抛出，还要具体问题具体分析。
5 总结
本文先介绍了 ClassLoader 的作用：主要用于从指定路径查找 class 并加载到内存，另外是判断两个类是否相等。
后面介绍了双亲委派模型，以及其实现原理，JDK 中主要是在 ClassLoader 的 loadClass 方法中实现双亲委派模型的。
然后代码示例说明了如何实现自己的类加载器，以及类加载器的使用场景。
最后说明了在工作中常遇到的两个与类加载器相关的异常。