JVM——自定义类加载器

0. 为什么需要自定义类加载器  

网上的大部分自定义类加载器文章，几乎都是贴一段实现代码，然后分析一两句自定义ClassLoader的原理。但是我觉得首先得把为什么需要自定义加载器这个问题搞清楚，因为如果不明白它的作用的情况下，还要去学习它显然是很让人困惑的。

首先介绍自定义类的应用场景：

（1）加密：Java代码可以轻易的被反编译，如果你需要把自己的代码进行加密以防止反编译，可以先将编译后的代码用某种加密算法加密，类加密后就不能再用Java的ClassLoader去加载类了，这时就需要自定义ClassLoader在加载类的时候先解密类，然后再加载。

（2）从非标准的来源加载代码：如果你的字节码是放在数据库、甚至是在云端，就可以自定义类加载器，从指定的来源加载类。

（3）以上两种情况在实际中的综合运用：比如你的应用需要通过网络来传输 Java 类的字节码，为了安全性，这些字节码经过了加密处理。这个时候你就需要自定义类加载器来从某个网络地址上读取加密后的字节代码，接着进行解密和验证，最后定义出在Java虚拟机中运行的类。

1. 双亲委派模型

在实现自己的ClassLoader之前，我们先了解一下系统是如何加载类的，那么就不得不介绍双亲委派模型的实现过程。

[java] view plain copy

1. //双亲委派模型的工作过程源码  
2. protected synchronized Class<?> loadClass(String name, boolean resolve)  
3. throws ClassNotFoundException  
4. {  
5. // First, check if the class has already been loaded  
6. Class c = findLoadedClass(name);  
7. if (c == null) {  
8. try {  
9. if (parent != null) {  
10. c = parent.loadClass(name, false);  
11. } else {  
12. c = findBootstrapClassOrNull(name);  
13. }  
14. } catch (ClassNotFoundException e) {  
15. // ClassNotFoundException thrown if class not found  
16. // from the non-null parent class loader  
17. //父类加载器无法完成类加载请求  
18. }  
19. if (c == null) {  
20. // If still not found, then invoke findClass in order to find the class  
21. //子加载器进行类加载   
22. c = findClass(name);  
23. }  
24. }  
25. if (resolve) {//判断是否需要链接过程，参数传入  
26. resolveClass(c);  
27. }  
28. return c;  
29. }  

双亲委派模型的工作过程如下：

（1）当前类加载器从自己已经加载的类中查询是否此类已经加载，如果已经加载则直接返回原来已经加载的类。

（2）如果没有找到，就去委托父类加载器去加载（如代码c = parent.loadClass(name, false)所示）。父类加载器也会采用同样的策略，查看自己已经加载过的类中是否包含这个类，有就返回，没有就委托父类的父类去加载，一直到启动类加载器。因为如果父加载器为空了，就代表使用启动类加载器作为父加载器去加载。

（3）如果启动类加载器加载失败（例如在$JAVA_HOME/jre/lib里未查找到该class），会使用拓展类加载器来尝试加载，继续失败则会使用AppClassLoader来加载，继续失败则会抛出一个异常ClassNotFoundException，然后再调用当前加载器的findClass()方法进行加载。

 

双亲委派模型的好处：

（1）主要是为了安全性，避免用户自己编写的类动态替换 Java的一些核心类，比如 String。

（2）同时也避免了类的重复加载，因为 JVM中区分不同类，不仅仅是根据类名，相同的 class文件被不同的 ClassLoader加载就是不同的两个类。

2. 自定义类加载器

（1）从上面源码看出，调用loadClass时会先根据委派模型在父加载器中加载，如果加载失败，则会调用当前加载器的findClass来完成加载。

（2）因此我们自定义的类加载器只需要继承ClassLoader，并覆盖findClass方法，下面是一个实际例子，在该例中我们用自定义的类加载器去加载我们事先准备好的class文件。

2.1 自定义一个People.java类做例子

[java] view plain copy

1. public class People {  
2. //该类写在记事本里，在用javac命令行编译成class文件，放在d盘根目录下  
3.     private String name;  
4.   
5.     public People() {}  
6.   
7.     public People(String name) {  
8.         this.name = name;  
9.     }  
10.   
11.     public String getName() {  
12.         return name;  
13.     }  
14.   
15.     public void setName(String name) {  
16.         this.name = name;  
17.     }  
18.   
19.     public String toString() {  
20.         return "I am a people, my name is " + name;  
21.     }  
22.   
23. }  

2.2 自定义类加载器

自定义一个类加载器，需要继承ClassLoader类，并实现findClass方法。其中defineClass方法可以把二进制流字节组成的文件转换为一个java.lang.Class（只要二进制字节流的内容符合Class文件规范）。

[java] view plain copy

1. import java.io.ByteArrayOutputStream;  
2. import java.io.File;  
3. import java.io.FileInputStream;  
4. import java.nio.ByteBuffer;  
5. import java.nio.channels.Channels;  
6. import java.nio.channels.FileChannel;  
7. import java.nio.channels.WritableByteChannel;  
8.   
9. public class MyClassLoader extends ClassLoader  
10. {  
11.     public MyClassLoader()  
12.     {  
13.           
14.     }  
15.       
16.     public MyClassLoader(ClassLoader parent)  
17.     {  
18.         super(parent);  
19.     }  
20.       
21.     protected Class<?> findClass(String name) throws ClassNotFoundException  
22.     {  
23.         File file = new File("D:/People.class");  
24.         try{  
25.             byte[] bytes = getClassBytes(file);  
26.             //defineClass方法可以把二进制流字节组成的文件转换为一个java.lang.Class  
27.             Class<?> c = this.defineClass(name, bytes, 0, bytes.length);  
28.             return c;  
29.         }   
30.         catch (Exception e)  
31.         {  
32.             e.printStackTrace();  
33.         }  
34.           
35.         return super.findClass(name);  
36.     }  
37.       
38.     private byte[] getClassBytes(File file) throws Exception  
39.     {  
40.         // 这里要读入.class的字节，因此要使用字节流  
41.         FileInputStream fis = new FileInputStream(file);  
42.         FileChannel fc = fis.getChannel();  
43.         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
44.         WritableByteChannel wbc = Channels.newChannel(baos);  
45.         ByteBuffer by = ByteBuffer.allocate(1024);  
46.           
47.         while (true){  
48.             int i = fc.read(by);  
49.             if (i == 0 || i == -1)  
50.             break;  
51.             by.flip();  
52.             wbc.write(by);  
53.             by.clear();  
54.         }  
55.         fis.close();  
56.         return baos.toByteArray();  
57.     }  
58. }  

2.3 在主函数里使用

[java] view plain copy

1. MyClassLoader mcl = new MyClassLoader();   
2. Class<?> clazz = Class.forName("People", true, mcl);   
3. Object obj = clazz.newInstance();  
4.          
5. System.out.println(obj);  
6. System.out.println(obj.getClass().getClassLoader());//打印出我们的自定义类加载器  

2.4 运行结果

至此关于自定义ClassLoader的内容总结完毕。

转载请注明出处：http://blog.csdn.net/seu_calvin/article/details/52315125