public class Launcher {
static class AppClassLoader extends URLClassLoader {}
static class ExtClassLoader extends URLClassLoader {}
}
JVM 加载任意一个类时,委托至顶级加载器 Bootstrap ClassLoader, Bootstrap 会加载Launcher.class(不需要编译,直接存在于rt.jar中)
也即是Bootstrap 启动完成, AppClassLoader,ExtClassLoader已成为可用状态
public class URLClassLoader extends SecureClassLoader implements Closeable {}
public class SecureClassLoader extends ClassLoader {}
protected final Class<?> defineClass(String name, byte[] b, int off, int len){
return defineClass(name, b, off, len, null);
}
native 方法读取字节数组, 也就是我们平常说的字节码文件,也可以根据字节流换成来读取一个资源
native 原生就支持加载编译好的.class文件,网络传输中的.class文件, 甚至是自己new 出来的字节数组
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
// native 读取是否已经加载了类
private native final Class<?> findLoadedClass0(String name);
protected Class<?> loadClass(String name, boolean resolve) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
try {
// 递归寻找父加载器
if (parent != null) {
c = parent.loadClass(name, false);
else
//parent == null 时 访问到顶级加载器
c = findBootstrapClassOrNull(name);
} catch (ClassNotFoundException e) {
}
if (c == null) {
// findClass找到class文件后将调用defineClass方法把字节码导入方法区,同时缓存结果
c = findClass(name);
}
}
}
AppClassLoader 和 ExtClassLoader 都使用的是变双亲委派的规则
protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}
// 搜索路径
private final URLClassPath ucp;
protected Class<?> findClass(final String name) {
final Class<?> result;
result = AccessController.doPrivileged(new PrivilegedExceptionAction<Class<?>>(){
public Class<?> run() throws ClassNotFoundException {
String path = name.replace('.', '/').concat(".class");
// 找自己路径下的class文件
Resource res = ucp.getResource(path, false);
if (res != null) {
// 找到了就注入
return defineClass(name, res);
} else {
return null;
}
}
}, acc);
if (result == null) {
throw new ClassNotFoundException(name);
}
return result;
}
保证最核心的类最先加载,核心类加载了,其他用户自定义的类才不会出现依赖问题。
Bootstrap ClassLoader 是对用户不可见的类加载器,也是顶级加载器,%Java_Home%/lib下面的核心类会优先加载,如果用户自己定义了java.lang.Integer
, 程序只能使用AppClassLoader
来进行加载,一旦执行到其父类URLClassLoader的
findClass()`中的语句时,会跳过加载同名的类
Class<?> c = findLoadedClass(name);
值得一提的是,类加载器加载网络中的java.lang.Integer
,这个时候需要另外一个机制来检测
URLClassLoader extends SecureClassLoader
, jdk自带的classLoader都拥有这个能力
public final Class<?> loadClass(String name, boolean resolve){
// First check if we have permission to access the package. This
// should go away once we've added support for exported packages.
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
int i = name.lastIndexOf('.');
if (i != -1) {
sm.checkPackageAccess(name.substring(0, i));
}
}
return super.loadClass(name, resolve);
}
使用自定义类加载器不继承 SecureClassLoader 是可以实现与 核心类同名的类共存,
原因:JVM 识别类的完全一致,需要全限定名 + 加载该类的类加载器
但是一般不这么做,所以也就有网上的一说:
建议自定义类加载器继承 URLClassLoader 理由之一是继承了 SecureClassLoader 尽可能保证安全性。
当然可以
loadClass
能够不遵循 @CallerSensitive
public static Class<?> forName(String className)
throws ClassNotFoundException {
Class<?> caller = Reflection.getCallerClass();
return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
}
private static native Class<?> forName0(String name, boolean initialize,
ClassLoader loader,
Class<?> caller)
throws ClassNotFoundException;
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// 从缓存中查找该类是否被载入
Class<?> c = findLoadedClass(name);
if (c == null) {
try {
if (parent != null) {
c = parent.loadClass(name, false);
}
} catch (ClassNotFoundException e) {
// 抛异常证明当前ClassLoader目录下不存在目标类
// 使用catch调度程序继续执行
}
if (c == null) {
// findClass 暴露给子类实现,让破坏双亲委派成为了可能
c = findClass(name);
}
}
return c;
}
}
用户使用 ClassLoader.loadClass() 实质上就是在使用双亲委派模型
findClass(name) 组合了 findClass(name), findClass()只是双亲委派的拓展,可以自己拓展类的检索路径
如上文提到,class.forName()
调用的是native方法,不走双亲委派的代码
public class Launcher {
static class AppClassLoader extends URLClassLoader {}
static class ExtClassLoader extends URLClassLoader {}
public Launcher() {
try {
this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
}
// 把AppClassLoader设置为线程的加载器
Thread.currentThread().setContextClassLoader(this.loader);
}
}
Launcher实例化后会将AppClassLoader 设置在 AppClassLoader ExtClassLoader 的线程上下文中
也就是加载核心类后,加载自定义类前,这个加载类的线程,能够拿到AppClassLoader
setContextClassLoader(this.loader); 在SPI打破双亲委派模型起关键的作用