前言
Java中的类加载器在开发过程中大家想必都听过，大多数人却接触的不多，但是这是jdk中一个非常核心的组件。
一、java中的类加载是什么？
简单的来说就是把编译好的class文件通过jdk的类加载器从磁盘载入jvm，变成我们可以使用的java类。
二、类加载的过程
加载(从磁盘载入class字节码) >> 验证(校验class文件的合法性) >> 准备(分配内存，静态变量赋默认值，如int i=0) >> 解析(符号引用->直接引用) >> 初始化(静态变量赋值，执行静态代码块) >> 创建class对象
这里主要讲一下解析这一步，这一步会把符号引用替换为直接引用，class字节码中的静态字面量、静态方法名等就是符号引用，载入方法区后，这些符号引用将被替换为直接指向内存地址的直接引用。
一个类被加载入方法区后，方法区会存在这个类的运行时常量池(前面的符号引用)，类型信息，方法体信息、类加载器的引用、class对象的引用。
二、双亲委派机制
在解释双亲委派前，我们先来看另一个东西：类加载器。前面看了类加载的过程，但这个过程是由谁来执行的呢？我们知道java是面向对象语言，所以这个过程当然还是由某一个对象来实现的，这个对象就是类加载器classLoader。java中的类加载器主要分为以下几种：
- 引导类加载器bootstrapClassLoader：加载支撑JVM运行的位于JRE的lib目录下的核心类库，比如 rt.jar、charsets.jar等
- 扩展类加载器extClassLoader：加载支撑JVM运行的位于JRE的lib目录下的ext扩展目录中的JAR类包
- 应用程序类加载器appClassLoader：负责加载ClassPath路径下的类包，主要就是加载我们写的那些类
而所谓双亲委派机制，就是当要加载一个类的时候，当前加载器不会自己加载，而是会委托给自己的父加载器加载，一切都要从Launcher这个类说起，这个类由引导类加载器加载，并在程序启动时创建类实例，这里要注意的是，引导类加载器并不是一个java的类，而是由java虚拟机创建，底层是c++实现。而扩展类加载器和应用程序类加载器都是Launcher的内部类，下面来看Launcher构造器源码：
public Launcher() {
Launcher.ExtClassLoader var1; //扩展类加载器
try {
var1 = Launcher.ExtClassLoader.getExtClassLoader();
} catch (IOException var10) {
throw new InternalError("Could not create extension class loader", var10);
}
try {
this.loader = Launcher.AppClassLoader.getAppClassLoader(var1); //应用程序类加载器
} catch (IOException var9) {
throw new InternalError("Could not create application class loader", var9);
}
Thread.currentThread().setContextClassLoader(this.loader);
String var2 = System.getProperty("java.security.manager");
if (var2 != null) {
SecurityManager var3 = null;
if (!"".equals(var2) && !"default".equals(var2)) {
try {
var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
} catch (IllegalAccessException var5) {
} catch (InstantiationException var6) {
} catch (ClassNotFoundException var7) {
} catch (ClassCastException var8) {
}
} else {
var3 = new SecurityManager();
}
if (var3 == null) {
throw new InternalError("Could not create SecurityManager: " + var2);
}
System.setSecurityManager(var3);
}
}
Launcher内部维护了了一个默认的类加载器对象变量：
private ClassLoader loader;public ClassLoader getClassLoader() { return this.loader; }
从上面的构造方法中我们可以看到这个loader其实就是AppClassLoader，因为双亲委派机制，java默认最先用AppClassLoader去尝试加载类。其流程如下图所示：
这样的机制保证了：
- 一个类不会被重复加载。
- 你无法自行加载一个例如名为java.lang.String的类。
下面我们来看双亲委派这个过程的底层原理：
加载一个类的时候，首先进入AppClassLoader的loadClass方法：
public Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
int var3 = var1.lastIndexOf(46);
if (var3 != -1) {
SecurityManager var4 = System.getSecurityManager();
if (var4 != null) {
var4.checkPackageAccess(var1.substring(0, var3));
}
}
if (this.ucp.knownToNotExist(var1)) {
Class var5 = this.findLoadedClass(var1);
if (var5 != null) {
if (var2) {
this.resolveClass(var5);
}
return var5;
} else {
throw new ClassNotFoundException(var1);
}
} else {
return super.loadClass(var1, var2); //主要看这里，调用父类的loadClass方法
}
}
AppClassLoader和extClassLoader均继承自URLClassLoader，URLClassLoader的loadClass方法又会调用自己父类的同名方法，最终走到ClassLoader这个抽象类，直接看ClassLoader.loadClass():
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) {
//调用自己的parent的loadClass方法，注意这里并不是super，AppClassLoader的parent是extClassLoader
c = parent.loadClass(name, false);
} else {
//最终会走到这里，因为extClassLoader的parent为null（虽然可以认为bootstrapClassLoader就是extClassLoader的parent）
c = findBootstrapClassOrNull(name);
}
} 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();
//我们可以看到上面是嵌套调用 loadClass方法，如果是加载我们自己写的类，那extClassLoader和bootstrapClassLoader找不到类也无法加载，findBootstrapClassOrNull(name)返回 null，extClassLoader的loadClass方法也会返回null，只能由AppClassLoader加载，最终会执行AppClassLoader的findClass方法。
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;
}
}
下面进入findClass，这个方法在URLClassLoader：
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);
}
} else {
return null;
}
}
}, acc);
} catch (java.security.PrivilegedActionException pae) {
throw (ClassNotFoundException) pae.getException();
}
if (result == null) {
throw new ClassNotFoundException(name);
}
return result;
}
findClass就比较简单了，调用defineClass完成加载类的最后一步，这个方法最终会调用本地方法从字节码文件加载类。至此成功的加载了一个类。
四、自定义类加载器
有时候我们会有加载同名的类的需求，这是我们就需要打破双亲委派机制，需求自己写一个类加载器满足，首先创建一个自定义类加载器继承ClassLoader并重写findClass和loadClass方法：
public class CustomClassLoader extends ClassLoader{
private String classPath;
public CustomClassLoader(String classPath){
this.classPath=classPath;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] bytes=null;
int len=0;
//找到要加载的类的class文件路径，并读入字节码
try(FileInputStream fis=new FileInputStream(classPath+"/"+name.replace(".","/")+".class")){
len=fis.available();
bytes=new byte[len];
fis.read(bytes);
}catch (Exception e){
e.printStackTrace();
}
//调用本地方法加载
return defineClass(name, bytes,0, len);
}
@Override
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();
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
//如果是要自己加载的类就直接自己加载，打破双亲委派，如果是其他被引用到的或父类，则让parent加载
if(name.endsWith("xxx")){
c = findClass(name);
}else{
c=this.getParent().loadClass(name);//注意这里不能写super.loadClass,否侧会进入调用死循环
}
// 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;
}
}
}
这样我们在用自定义类加载器加载类的时候只需要指定相应的classPath 即可：
CustomClassLoader classLoader=new CustomClassLoader("classPath");
扫一扫
167
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
