java类加载器探究
java内置类加载器
java内置了三层次结构的类加载器
1：启动类加载器也叫引导类加载器 （Bootstrap） 加载JAVA_HOME/lib 下的类 比如rt.jar
2：扩展类加载器（ExtClassLoader） 加载JAVA_HOME/lib/ext 下的类
3：应用程序类加载器（AppClassLoader） 加载应用程序CLASSPATH下的class文件
一个加载器在加载一个类的时候，都要先使用它的父类加载器去加载这个类，如果它的父类加载器可以加载这个类，
那么就用父类加载器加载这个类，否则自己加载这个类。
下面看一段程序：
public class Test {
public static void main(String[] args) {
//应用类加载器 Test在classpath下 所以AppClassLoader会加载这个类
System.out.println(Test.class.getClassLoader().getClass().getName());
//启动类加载器 System类是rt.jar 包下的类 是启动类加载器加载的，但是启动类加载器对程序不可见，得到的是null
System.out.println(System.class.getClassLoader());
//三层类加载器结构
ClassLoader loader = Test.class.getClassLoader();
while (null != loader) {
System.out.println(loader.getClass().getName());
loader = loader.getParent();
}
System.out.println(loader);
}
}
输出结果如下：
sun.misc.Launcher$AppClassLoader null sun.misc.Launcher$AppClassLoader sun.misc.Launcher$ExtClassLoader null
自定义类加载器
自定义的类加载器 继承ClassLoader，推荐只重写findClass方法，这样就维持了加载器的父类委派机制。
它的父类加载器默认为AppClassLoader。
package com.load;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
class MyClassLoader extends ClassLoader {
// 类存放的路径
private String classpath;
public MyClassLoader(String classpath){
this.classpath = classpath;
}
/**
* 重写findClass方法
*/
@Override
public Class<?> findClass(String name) {
byte[] data = loadClassData(name);
return this.defineClass(name, data, 0, data.length);
}
public byte[] loadClassData(String name) {
System.out.println("加载"+name); //注意这里的输出
try {
name = name.replace(".", "//");
FileInputStream is = new FileInputStream(new File(classpath + name + ".class"));
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int b = 0;
while ((b = is.read()) != -1) {
baos.write(b);
}
is.close();
return baos.toByteArray();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
验证一下父类委派机制.
public void testParentLoader() throws ClassNotFoundException{
//com.load.Test 此类在classpath下
MyClassLoader loader = new MyClassLoader("F:\\workspace\\chutest\\bin");
Class<?> loadClass = loader.loadClass("com.load.Test");
System.out.println(loadClass.getClassLoader());
MyClassLoader loader1 = new MyClassLoader("F:\\workspace\\chutest\\bin");
Class<?> loadClass1 = loader1.loadClass("com.load.Test");
System.out.println(loadClass1.getClassLoader());
}
输出如下：
sun.misc.Launcher$AppClassLoader@106d69c sun.misc.Launcher$AppClassLoader@106d69c
从这里的输出我们看到，两次类加载都没有调用MyClassLoader的findClass方法。
在加载的过程中，先要调用父类AppClassLoader来加载此类，因为com.load.Test在classpath下
所以父类加载器可以加载这个类，然后直接就把这个类加载了，并没有调用子类的加载方法。
还可以看出两次加载得到的class对象是一致的。其实第二次其实并没有加载，在类加载的时候
首先会查看这个类是否加载过，如果已经加载了就不再加载，直接返回之前的class对象。
加载classpath之外的类，在d盘下新建一个类，如下：
package com.load;
public class Apple{
static{
System.out.println("int Apple");
}
public void say(){
System.out.println("I am a apple..");
}
}
加载这个类：
public void testDiffLoader() throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
MyClassLoader myLoader = new MyClassLoader("D:/");
Class<?> clazz = myLoader.loadClass("com.load.Apple");
Class<?> clazz1 = myLoader.loadClass("com.load.Apple");
System.out.println(clazz == clazz1);
System.out.println(clazz.getClassLoader());
System.out.println(clazz1.getClassLoader());
System.out.println("================");
MyClassLoader myLoader1 = new MyClassLoader("D:/");
Class<?> clazz2 = myLoader1.loadClass("com.load.Apple");
System.out.println(clazz2 == clazz1 );
System.out.println(clazz2.getClassLoader());
System.out.println("================");
Object newInstance = clazz.newInstance();
Method declaredMethod = clazz.getDeclaredMethod("say", new Class[]{});
declaredMethod.invoke(newInstance, new Object[]{});
}
输出如下：
加载com.load.Apple true com.load.MyClassLoader@1d6c5e0 com.load.MyClassLoader@1d6c5e0 ================ 加载com.load.Apple false com.load.MyClassLoader@1aeb7ab ================ int Apple I am a apple..
从输出我们看到，这次的加载不是父类加载器加载的，因为这个类并不在AppClassLoader的加载范围之内。
我们使用myLoader加载了两次Apple类，从输出结果我们看到这两次加载的结果是一致的。
因为我们使用了同一个类加载器myLoader
然后我们用myLoader1重新加载一次Apple类，这次输出和前两次输出的结果是不一样的。
也就是说这次加载和前两次加载得到的class对象是不一样的。
tomcat也自定义了类加载器。每个部署的tomcat下的项目都使用不同的类加载器来加载，所以项目与项目之前的类
是不可公用的。这也是自定义类加载器的用处之一。其实tomcat中的类加载器分为
1：catalina加载器
2：公共类加载器
3：分享类加载器
对tomcat类加载器有兴趣的同学，可以深入看一下tomcat源码。