Spring 中的類加載機制 - ClassLoader

Spring 系列目錄(https://www.cnblogs.com/binarylei/p/10198698.html)

ClassLoader JVM 類加載機制系列文章：

1. Java - ClassLoader
2. Spring 中的類加載機制 - ClassLoader

一、OverridingClassLoader 中的使用

OverridingClassLoader 是 Spring 自定義的類加載器，默認會先自己加載(excludedPackages 或 excludedClasses 例外)，只有加載不到才會委托給雙親加載，這就破壞了 JDK 的雙親委派模式。

@Test
public void testOverridingClassLoader() throws Exception {
    ClassLoader appClassLoader = Thread.currentThread().getContextClassLoader();

    // 添加到 excludedPackages 或 excludedClasses 的類就不會被代理的 ClassLoader 加載
    // 而會使用 JDK 默認的雙親委派機制
    // 因此 TestBean 不會被 OverridingClassLoader 重新加載，而 ITestBean 會重新加載
    OverridingClassLoader overridingClassLoader = new OverridingClassLoader(appClassLoader);
    overridingClassLoader.excludeClass(TestBean.class.getName());

    Class<?> excludedClazz1 = appClassLoader.loadClass(TestBean.class.getName());
    Class<?> excludedClazz2 = overridingClassLoader.loadClass(TestBean.class.getName());
    Assert.assertTrue("TestBean will exclude from OverridingClassLoader, so no reload",
            excludedClazz1 == excludedClazz2);

    Class<?> nonExcludedClazz1 = appClassLoader.loadClass(ITestBean.class.getName());
    Class<?> nonExcludedClazz2 = overridingClassLoader.loadClass(ITestBean.class.getName());
    Assert.assertFalse("ITestBean will not exclude, so reload again",
            nonExcludedClazz1 == nonExcludedClazz2);
}

可以看到，ITestBean 被 OverridingClassLoader 重新加載了一次，而 TestBean 添加到了 excludedClasses 中還是使用 JDK 的默認加載器，因此不會被重新加載。

二、OverridingClassLoader 源碼分析

2.1 DecoratingClassLoader

DecoratingClassLoader 很簡單，內部維護了兩個集合，如果你不想你的類被自定義的類加載器管理，可以把它添加到這兩個集合中，這樣仍使用 JDK 的默認類加載機制。

private final Set<String> excludedPackages = Collections.newSetFromMap(new ConcurrentHashMap<>(8));
private final Set<String> excludedClasses = Collections.newSetFromMap(new ConcurrentHashMap<>(8));

// isExcluded 返回 true 時仍使用 JDK 的默認類加載機制，返回 false 時自定義的類加載器生效
protected boolean isExcluded(String className) {
    if (this.excludedClasses.contains(className)) {
        return true;
    }
    for (String packageName : this.excludedPackages) {
        if (className.startsWith(packageName)) {
            return true;
        }
    }
    return false;
}

2.2 OverridingClassLoader

(1) loadClass

isEligibleForOverriding() 返回 true 時使用 OverridingClassLoader 先加載，只有加載不到才會雙親委派，否則直接進行雙親委派。代碼很簡單就不細看了。

@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
    if (this.overrideDelegate != null && isEligibleForOverriding(name)) {
        return this.overrideDelegate.loadClass(name);
    }
    return super.loadClass(name);
}

@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    if (isEligibleForOverriding(name)) {
        Class<?> result = loadClassForOverriding(name);
        if (result != null) {
            if (resolve) {
                resolveClass(result);
            }
            return result;
        }
    }
    return super.loadClass(name, resolve);
}

// isExcluded(className)=false 時說明沒有添加到 excludedPackages 或 excludedClasses
// 此時可以使用自定義的類加載器加載
protected boolean isEligibleForOverriding(String className) {
    return !isExcluded(className);
}

(2) loadClassForOverriding

loadClassForOverriding 也是從 classpath 直接找到對應的 .class 文件，然后重新加載。

protected Class<?> loadClassForOverriding(String name) throws ClassNotFoundException {
    Class<?> result = findLoadedClass(name);
    if (result == null) {
        byte[] bytes = loadBytesForClass(name);
        if (bytes != null) {
            result = defineClass(name, bytes, 0, bytes.length);
        }
    }
    return result;
}

protected byte[] loadBytesForClass(String name) throws ClassNotFoundException {
    InputStream is = openStreamForClass(name);
    if (is == null) {
        return null;
    }
    try {
        byte[] bytes = FileCopyUtils.copyToByteArray(is);
        // transformIfNecessary 留給子類重寫
        return transformIfNecessary(name, bytes);
    } catch (IOException ex) {
        throw new ClassNotFoundException("Cannot load resource for class [" + name + "]", ex);
    }
}

protected InputStream openStreamForClass(String name) {
    String internalName = name.replace('.', '/') + CLASS_FILE_SUFFIX;
    return getParent().getResourceAsStream(internalName);
}

---

每天用心記錄一點點。內容也許不重要，但習慣很重要！