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 源码分析

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

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

posted on 2019-01-24 08:23  binarylei  阅读(21812)  评论(0编辑  收藏  举报

导航