Java——类加载器探究

Java内置类加载器

java内置了三层次结构的类加载器
1：启动类加载器也叫引导类加载器 （Bootstrap）     加载JAVA_HOME/lib 下的类 比如rt.jar（加载系统jar包，对程序不可见的）
2：扩展类加载器（ExtClassLoader）      加载JAVA_HOME/lib/ext 下的类
3：应用程序类加载器（AppClassLoader）     加载应用程序CLASSPATH下的class文件
一个加载器在加载一个类的时候，都要先使用它的父类加载器去加载这个类，如果它的父类加载器可以加载这个类，
那么就用父类加载器加载这个类，否则自己加载这个类。
下面看一段程序：

[java]  view plain  copy

1. package com.lyz.classloader.test;  
2. /** 
3.  * Java类加载器 
4.  * @author liuyazhuang 
5.  * 
6.  */  
7. public class Test {  
8.   
9.     public static void main(String[] args) {  
10.           
11.         //应用类加载器   Test在classpath下 所以AppClassLoader会加载这个类  
12.         System.out.println(Test.class.getClassLoader().getClass().getName());  
13.   
14.         //启动类加载器    System类是rt.jar 包下的类 是启动类加载器加载的，但是启动类加载器对程序不可见，得到的是null  
15.         System.out.println(System.class.getClassLoader());  
16.   
17.         //扩展类加载器结构  
18.         ClassLoader loader = Test.class.getClassLoader();  
19.         while (null != loader) {  
20.             System.out.println(loader.getClass().getName());  
21.             loader = loader.getParent();  
22.         }  
23.         System.out.println(loader);  
24.     }  
25. }  

输出结果如下：

[plain]  view plain  copy

1. sun.misc.Launcher$AppClassLoader  
2. null  
3. sun.misc.Launcher$AppClassLoader  
4. sun.misc.Launcher$ExtClassLoader  
5. null  

自定义类加载器

自定义的类加载器 继承ClassLoader，推荐只重写findClass方法，这样就维持了加载器的父类委派机制。它的父类加载器默认为AppClassLoader。

[java]  view plain  copy

1. package com.lyz.classloader.test;  
2.   
3. import java.io.ByteArrayOutputStream;  
4. import java.io.File;  
5. import java.io.FileInputStream;  
6.   
7. /** 
8.  * 自定义类加载器 
9.  * @author liuyazhuang 
10.  * 
11.  */  
12. public class MyClassLoader extends ClassLoader {  
13.     // 类存放的路径  
14.     private String classpath;  
15.   
16.     public MyClassLoader(String classpath){  
17.         this.classpath = classpath;  
18.     }  
19.       
20.     /** 
21.      * 重写findClass方法 
22.      */  
23.     @Override  
24.     public Class<?> findClass(String name) {  
25.         byte[] data = loadClassData(name);  
26.         return this.defineClass(name, data, 0, data.length);  
27.     }  
28.   
29.     public byte[] loadClassData(String name) {  
30.         System.out.println("加载"+name); //注意这里的输出  
31.         try {  
32.             name = name.replace(".", "//");  
33.             FileInputStream is = new FileInputStream(new File(classpath + name + ".class"));  
34.             ByteArrayOutputStream baos = new ByteArrayOutputStream();  
35.             int b = 0;  
36.             while ((b = is.read()) != -1) {  
37.                 baos.write(b);  
38.             }  
39.             is.close();  
40.             return baos.toByteArray();  
41.         } catch (Exception e) {  
42.             e.printStackTrace();  
43.         }  
44.         return null;  
45.     }  
46. }  

验证一下父类委派机制.

[java]  view plain  copy

1. //验证一下父类委派机制.  
2. @Test  
3. public void testParentLoader() throws ClassNotFoundException{  
4.     //com.load.Test 此类在classpath下  
5.     MyClassLoader loader = new MyClassLoader("D:\\Workspaces\\MySelf\\Test\\bin\\");  
6.     Class<?> loadClass = loader.loadClass("com.lyz.classloader.test.MyClassLoaderTest");  
7.     System.out.println(loadClass.getClassLoader());  
8.       
9.       
10.     MyClassLoader loader1 = new MyClassLoader("D:\\Workspaces\\MySelf\\Test\\bin\\");  
11.     Class<?> loadClass1 = loader1.loadClass("com.lyz.classloader.test.MyClassLoaderTest");  
12.     System.out.println(loadClass1.getClassLoader());  
13. }  

运行结果如下：

[plain]  view plain  copy

1. sun.misc.Launcher$AppClassLoader@2a139a55  
2. sun.misc.Launcher$AppClassLoader@2a139a55  

从这里的输出我们看到，两次类加载都没有调用MyClassLoader的findClass方法。 在加载的过程中，先要调用父类AppClassLoader来加载此类，因为com.load.Test在classpath下所以父类加载器可以加载这个类，然后直接就把这个类加载了，并没有调用子类的加载方法。还可以看出两次加载得到的class对象是一致的。其实第二次其实并没有加载，在类加载的时候首先会查看这个类是否加载过，如果已经加载了就不再加载，直接返回之前的class对象。
加载classpath之外的类，在d盘下新建一个类，如下：

[java]  view plain  copy

1. package com.lyz.classloader.test;  
2.   
3. /** 
4.  * 测试在classpth以外的类 
5.  * @author liuyazhuang 
6.  * 
7.  */  
8. public class ClassOutOfClasspath {  
9.     static{  
10.         System.out.println("测试在classpath以外的类");  
11.     }  
12.     public void say(){  
13.         System.out.println("我是在classpath以外的类");  
14.     }  
15. }  

加载这个类：

[java]  view plain  copy

1. @Test  
2. public void testDiffLoader() throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {  
3.     MyClassLoader myLoader = new MyClassLoader("D:/");  
4.       
5.       
6.     Class<?> clazz = myLoader.loadClass("com.lyz.classloader.test.ClassOutOfClasspath");  
7.     Class<?> clazz1 = myLoader.loadClass("com.lyz.classloader.test.ClassOutOfClasspath");  
8.     System.out.println(clazz == clazz1);  
9.     System.out.println(clazz.getClassLoader());  
10.     System.out.println(clazz1.getClassLoader());  
11.       
12.     System.out.println("================");  
13.       
14.     MyClassLoader myLoader1 = new MyClassLoader("D:/");  
15.     Class<?> clazz2 = myLoader1.loadClass("com.lyz.classloader.test.ClassOutOfClasspath");  
16.     System.out.println(clazz2 == clazz1 );  
17.     System.out.println(clazz2.getClassLoader());  
18.       
19.     System.out.println("================");  
20.       
21.     Object newInstance = clazz.newInstance();  
22.     Method declaredMethod = clazz.getDeclaredMethod("say", new Class[]{});  
23.     declaredMethod.invoke(newInstance, new Object[]{});  
24. }  

输出结果如下：

[plain]  view plain  copy

1. 加载com.lyz.classloader.test.ClassOutOfClasspath  
2. true  
3. com.lyz.classloader.test.MyClassLoader@5010be6  
4. com.lyz.classloader.test.MyClassLoader@5010be6  
5. ================  
6. 加载com.lyz.classloader.test.ClassOutOfClasspath  
7. false  
8. com.lyz.classloader.test.MyClassLoader@7daf6ecc  
9. ================  
10. 测试在classpath以外的类  
11. 我是在classpath以外的类  

从输出我们看到，这次的加载不是父类加载器加载的，因为这个类并不在AppClassLoader的加载范围之内。 我们使用myLoader加载了两次ClassOutOfClasspath类，从输出结果我们看到这两次加载的结果是一致的。因为我们使用了同一个类加载器myLoader,然后我们用myLoader1重新加载一次ClassOutOfClasspath类，这次输出和前两次输出的结果是不一样的。也就是说这次加载和前两次加载得到的class对象是不一样的。
tomcat也自定义了类加载器。每个部署的tomcat下的项目都使用不同的类加载器来加载，所以项目与项目之间的类是不可共用的 。这也是自定义类加载器的用处之一。其实tomcat中的类加载器分为
1：catalina加载器
2：公共类加载器
3：分享类加载器
对tomcat类加载器有兴趣的同学，可以深入看一下tomcat源码。