Java类加载器
java虚拟机中带有三个类加载器
- Bootstrap ClassLoader：最顶层的加载类，主要加载核心类库。加载%JRE_HOME%\lib下的rt.jar、resources.jar、charsets.jar和class等。
- Extention ClassLoader：扩展的类加载器，加载目录%JRE_HOME%\lib\ext目录下的jar包和class文件。
- Appclass Loader：加载当前应用的classpath的所有类
public Launcher() {
// Create the extension class loader
ClassLoader extcl;
try {
extcl = ExtClassLoader.getExtClassLoader();
} catch (IOException e) {
throw new InternalError(
"Could not create extension class loader", e);
}
// Now create the class loader to use to launch the application
try {
//将ExtClassLoader对象实例传递进去
loader = AppClassLoader.getAppClassLoader(extcl);
} catch (IOException e) {
throw new InternalError(
"Could not create application class loader", e);
}
}
- AppClassLoader的parent是ExtClassLoader
- ExtClassLoader的parent是null
Bootstrap ClassLoader是由C/C++编写的，它本身是虚拟机的一部分，所以它并不是一个JAVA类，也就是无法在java代码中获取它的引用，JVM启动时通过Bootstrap类加载器加载rt.jar等核心jar包中的class文件，之前的int.class,String.class都是由它加载。
双亲委托机制
一个类加载器查找class和resource时，是通过“委托模式”进行的，它首先判断这个class是不是已经加载成功，如果没有的话它并不是自己进行查找，而是先通过父加载器，然后递归下去，直到Bootstrap ClassLoader，如果Bootstrap classloader找到了，直接返回，如果没有找到，则一级一级返回，最后到达自身去查找这些对象。这种机制就叫做双亲委托。
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// 首先，检测是否已经加载
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) {
//父加载器不为空则调用父加载器的loadClass
c = parent.loadClass(name, false);
} else {
//父加载器为空则调用Bootstrap Classloader
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();
//父加载器没有找到，则调用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()
resolveClass(c);
}
return c;
}
}
- 执行findLoadedClass(String)去检测这个class是不是已经加载过了。
- 执行父加载器的loadClass方法。如果父加载器为null，则jvm内置的加载器去替代，也就是Bootstrap ClassLoader。这也解释了ExtClassLoader的parent为null,但仍然说Bootstrap ClassLoader是它的父加载器。
- 如果向上委托父加载器没有加载成功，则通过findClass(String)查找。
为什么需要采用这种加载机制？
系统类远比用户的自定义类重要，当用户自定义类与系统完全相同时，这种机制可以保证优先正确的加载好系统核心类，保证系统本身的稳定运行
自定义classloader
- 想要运行时加载某个本地/从网络down下来的jar包的时候时，使用自定义classloader
- 一个ClassLoader创建时如果没有指定parent，那么它的parent默认就是AppClassLoader（这样才能够保证它能访问系统内置加载器加载成功的class文件）
下面这个是需要使用自定义classloader来进行加载的类，javac编译得到.class文件之后放到一个独立目录下
class MyClass {
public static void sayHello(){
System.out.println("hello, I'm a standalone class");
}
}
自定义DiskClassLoader，加载.class文件，输出Class
public class DiskClassLoader extends ClassLoader {
private String mLibPath;
public DiskClassLoader(String path) {
mLibPath = path;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
String fileName = getFileName(name);
File file = new File(mLibPath,fileName);
try {
FileInputStream is = new FileInputStream(file);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int len = 0;
try {
while ((len = is.read()) != -1) {
bos.write(len);
}
} catch (IOException e) {
e.printStackTrace();
}
byte[] data = bos.toByteArray();
is.close();
bos.close();
return defineClass(name,data,0,data.length);
} catch (IOException e) {
e.printStackTrace();
}
return super.findClass(name);
}
//获取要加载的class文件名
private String getFileName(String name) {
int index = name.lastIndexOf('.');
if(index == -1){
return name+".class";
}else{
return name.substring(index+1)+".class";
}
}
}
实际加载的代码
public class ClassLoaderTest {
public static void main(String[] args) {
//创建自定义classloader对象。
DiskClassLoader diskLoader = new DiskClassLoader("/Users/chaochen/Documents/git/SyntaxDemo/myownclass/MyClass.class");
try {
//加载class文件
Class c = diskLoader.loadClass("com.company.classloader.MyClass");
if(c != null){
Object obj = c.newInstance();
Method method = c.getDeclaredMethod("sayHello",null);
//通过反射调用Test类的say方法
method.invoke(obj, null);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
可以自定义加载之后，可以玩些其他什么？
- 热更新，一些业务类我们可以独立放在独立jar包中，通过检查更新来进行替换了
- class可以进行加密，只有我们自己可以使用
总结
假如需要我们自己来构建一套ClassLoader体系，我们需要考虑哪些问题？
- 如何将.class文件的内容转换成Class对象？ =>ClassLoader基类中包含了完成这个转换需要的逻辑
- 需要加载的类非常多？=>用时才加载
- 如何增加系统类的加载安全性，不会被替换？=> 分成多个不同的classloader，每个classloader负责自己独立的内容（路径），双亲加载机制，优先保证核心类的正确性
- 为开发者提供更多运行时工具？ => 容许自定义classloader
后续
ContextClassLoader这个文章里面说可以绕过双亲加载机制，后续有时间跟一下这个demo看看是怎么回事
