Spring 中的类加载机制 - ClassLoader
Spring 系列目录(https://www.cnblogs.com/binarylei/p/10198698.html)
ClassLoader JVM 类加载机制系列文章：
一、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);
}
每天用心记录一点点。内容也许不重要，但习惯很重要！