文章目录
类加载器
类加载器原理
加载器源码分析
ClassLoader是个抽象类。
private static native void registerNatives();
static {
registerNatives();
}
#这段代码的作用是什么?
成员变量:每个加载器都聚合了一个父加载器,相当于链表了。
// The parent class loader for delegation
// Note: VM hardcoded the offset of this field, thus all new fields
// must be added *after* it.
private final ClassLoader parent;
直接来看核心方法是如何加载类的:
* @param name
* The <a href="#name">binary name</a> of the class
*
* @param resolve
* If <tt>true</tt> then resolve the class
*
* @return The resulting <tt>Class</tt> object
*
* @throws ClassNotFoundException
* If the class could not be found
*/
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);//从缓存中找,找不到再加载
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) {//如果有父加载器,尝试用父加载
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
//否则用BootStrap加载
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name);//子类实现此方法,找不到直接报异常
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
//没报异常说明找到了!是否解析?待了解
if (resolve) {
resolveClass(c);
}
return c;
}
两个重要加载器的实现
父类均为URLClassLoader,重写了findClass();
直接根据路径取拿到字节码,具体代码后面补充(TODO)
构造器:
public URLClassLoader(URL[] urls, ClassLoader parent,
URLStreamHandlerFactory factory) {
super(parent);
// this is to make the stack depth consistent with 1.1
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkCreateClassLoader();
}
acc = AccessController.getContext();
ucp = new URLClassPath(urls, factory, acc);
}
protected Class<?> findClass(final String name)
throws ClassNotFoundException
{
final Class<?> result;
try {
result = AccessController.doPrivileged(
new PrivilegedExceptionAction<Class<?>>() {
public Class<?> run() throws ClassNotFoundException {
String path = name.replace('.', '/').concat(".class");
Resource res = ucp.getResource(path, false);
if (res != null) {
try {
return defineClass(name, res);//生成字节码文件,返回类对象
} catch (IOException e) {
throw new ClassNotFoundException(name, e);
} catch (ClassFormatError e2) {
if (res.getDataError() != null) {
e2.addSuppressed(res.getDataError());
}
throw e2;
}
} else {
return null;
}
}
}, acc);
} catch (java.security.PrivilegedActionException pae) {
throw (ClassNotFoundException) pae.getException();
}
if (result == null) {
throw new ClassNotFoundException(name);
}
return result;
}
1.扩展加载器
来看看扩展加载器的实现:
public ExtClassLoader(File[] var1) throws IOException {
super(getExtURLs(var1), (ClassLoader)null, Launcher.factory);
SharedSecrets.getJavaNetAccess().getURLClassPath(this).initLookupCache(this);
}
构造方法中父加载器为空
static class ExtClassLoader extends URLClassLoader {
private static volatile Launcher.ExtClassLoader instance;
// 显然这是个单例模式,写死的。
public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
if (instance == null) {
Class var0 = Launcher.ExtClassLoader.class;
synchronized(Launcher.ExtClassLoader.class) {
if (instance == null) {
instance = createExtClassLoader();
}
}
}
return instance;
}
private static Launcher.ExtClassLoader createExtClassLoader() throws IOException {
try {
return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction<Launcher.ExtClassLoader>() {
public Launcher.ExtClassLoader run() throws IOException {
File[] var1 = Launcher.ExtClassLoader.getExtDirs();//**java.ext.dirs**
int var2 = var1.length;
for(int var3 = 0; var3 < var2; ++var3) {
MetaIndex.registerDirectory(var1[var3]);
}//需要了解,可能是注册到到缓存表里?TODO
return new Launcher.ExtClassLoader(var1);//拿到对象了
}
});
} catch (PrivilegedActionException var1) {
throw (IOException)var1.getException();
}
}
获取扩展目录
private static File[] getExtDirs() {
String var0 = System.getProperty("java.ext.dirs");
//系统内部维护了一个property对象,底层是个hashtable
File[] var1;
if (var0 != null) {
StringTokenizer var2 = new StringTokenizer(var0, File.pathSeparator);//切分成token
int var3 = var2.countTokens();
var1 = new File[var3];
for(int var4 = 0; var4 < var3; ++var4) {
var1[var4] = new File(var2.nextToken());
}
} else {
var1 = new File[0];
}
return var1;//返回此目录下的所有文件集
}
public class ExtFiles {
public static void main(String[] args) {
System.out.println("java.ext.dirs的value:"+System.getProperty("java.ext.dirs"));
}//java.ext.dirs的value:D:\Java\jre\lib\ext;C:\Windows\Sun\Java\lib\ext
}
2.APP加载器
构造方法:
AppClassLoader(URL[] var1, ClassLoader var2) {
super(var1, var2, Launcher.factory);
this.ucp.initLookupCache(this);
}
获取loader的方式和扩展加载器不一样,具体区别先不作区分*(TODO)*
public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
final String var1 = System.getProperty("java.class.path");
final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);
return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
public Launcher.AppClassLoader run() {
URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);
return new Launcher.AppClassLoader(var1x, var0);
}
});
}
我们来看看这个键里存了哪些值:
localedata.jar
D:\Java\jre\lib\ext\nashorn.jar
D:\Java\jre\lib\ext\sunec.jar
D:\Java\jre\lib\ext\sunjce_provider.jar
D:\Java\jre\lib\ext\sunmscapi.jar
D:\Java\jre\lib\ext\sunpkcs11.jar
D:\Java\jre\lib\ext\zipfs.jar
D:\Java\jre\lib\javaws.jar
D:\Java\jre\lib\jce.jar
D:\Java\jre\lib\jfr.jar
D:\Java\jre\lib\jfxswt.jar
D:\Java\jre\lib\jsse.jar
D:\Java\jre\lib\management-agent.jar
D:\Java\jre\lib\plugin.jar
D:\Java\jre\lib\resources.jar
D:\Java\jre\lib\rt.jar
D:\Project\项目\Reback\JVM\target\classes
双亲委派机制及破坏
总结
至此我们知道了一个加载器是如何去加载一个类的了。但是:
谁来加载加载器
http://t.csdn.cn/gshgD
据此BootStrap加载器加载。
内建于JVM中的启动类加载器会加载java.lang.ClassLoader以及其他java平台类,当jvm启动时,一块特殊的机器码会运行,它会加载扩展类加载器与系统类加载器, 这块特殊的机器码叫做启动类加载器(Bootstarp)。启动类加载器并不是Java类,而其它加载器则都是Java类。 启动类加载器是特定于平台的机器指令,它负责开启整个加载过程。 所有类加载器(除了启动类加载器)都被实现为Java类,不过,总归要有一个组件来加载第一个Java类加载器,从而让整个加载过程能够顺利进行下去,加载第一个纯Java类加载器就是启动类加载器的职责。启动类加载器还会负责加载供JRE正常运行所需要的基本组件,这包括java.util与java.lang包中的类等等。
谁来加载类?
一般来说,类路径下的jar包以及类,都是由APP加载器来加载的,只有有具体的包信息,就可以去指定的路径去加载流;
我们知道loader可以选择性的去加载类,可是类一开始找谁加载呢;
(1)classForName()
@CallerSensitive
public static Class<?> forName(String className)
throws ClassNotFoundException {
Class<?> caller = Reflection.getCallerClass();
return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
}
/** Called after security check for system loader access checks have been made. */
private static native Class<?> forName0(String name, boolean initialize,
ClassLoader loader,
Class<?> caller)
throws ClassNotFoundException;
全是本地方法,咋看…到底使用哪个加载器呢,有网友说是当前加载器.
(2)new对象的时候找哪个加载器?
(3)引入的jar包的加载器是谁?
引入的jar包或者我们在idea中字节写的类,加载器都是app类加载器;
什么时候需要实现一个加载器
如何实现一个加载器
Java类加载机制
http://t.csdn.cn/yRfKC