Spring 中的类加载机制 - ClassLoader

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);
}

---

每天用心记录一点点。内容也许不重要，但习惯很重要！