类加载器的委托模式

类加载器在尝试自己去查找某个类的字节代码并定义它时，会先代委托给其父类加载器，由父类加载器先去尝试加载这个类，依次类推。在介绍委托模式背后的动机之前，首先需要说明一下 Java 虚拟机是如何判定两个 Java 类是相同的。Java 虚拟机不仅要看类的全名是否相同，还要看加载此类的类加载器是否一样。只有两者都相同的情况，才认为两个类是相同的。即便是同样的字节代码，被不同的类加载器加载之后所得到的类，也是不同的。比如一个 Java 类com.tao.test.ClassTest，编译之后生成了字节代码文件ClassTest.class。两个不同的类加载器ClassLoaderA和 ClassLoaderB分别读取了这个ClassTest.class文件，并定义出两个java.lang.Class类的实例来表示这个类。这两个实例是不相同的。对于 Java 虚拟机来说，它们是不同的类。试图对这两个类的对象进行相互赋值，会抛出运行时异常ClassCastException。下面通过上面一讲的示例来具体比较

 1 public class Test {
 2     public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
 3         Class clazz1=new MyClassLoader().loadClass("com.tao.test.ClassTest");
 4         Class clazz2=new MyClassLoader().loadClass("com.tao.test.ClassTest");
 5         //这是由不同的类加载器加载的类生成的对象
 6         InterfaceTest classTest1=(InterfaceTest) clazz1.newInstance();
 7         InterfaceTest classTest2=(InterfaceTest) clazz2.newInstance();
 8         //这是Date对象，是由同一个类加载器加载的
 9         Date date1=new Date();
10         Date date2=new Date();
11         //比较他们是否是同一个Class类的实例
12         System.out.println(date1.getClass().equals(date2.getClass()));
13         System.out.println(classTest1.getClass().equals(classTest2.getClass()));
14     }
15 }

结果是：

1 true
2 false

 

类加载器是怎么进行委托的呢，我们可以查看下ClassLoader的源码分析下。

因为，在加载一个类的时候，都是调用loadClass()方法，所以具体看下loadClass()方法

 1 //有两个loadClass()方法，不会最终都是调用第二个方法  
 2 public Class<?> loadClass(String name) throws ClassNotFoundException {  
 3         return loadClass(name, false);  
 4     }  
 5   
 6 //最终调用的loadClass()方法   
 7 protected Class<?> loadClass(String name, boolean resolve)  
 8         throws ClassNotFoundException  
 9     {  
10         //异步保护，防止重复加载一个相同的类  
11         synchronized (getClassLoadingLock(name)) {  
12             // 检测这个类是否被加载了  
13             Class c = findLoadedClass(name);  
14             //如果没有被加载，首先让父类去加载  
15             if (c == null) {  
16                 long t0 = System.nanoTime();  
17                 try {  
18                     if (parent != null) {//父类加载器不是null，也就是说不是BootStrap加载器  
19                         c = parent.loadClass(name, false);  
20                     } else {//父类加载器是BootStrap加载器  
21                         c = findBootstrapClassOrNull(name);  
22                     }  
23                 } catch (ClassNotFoundException e) {  
24                     // ClassNotFoundException thrown if class not found  
25                     // from the non-null parent class loader  
26                 }  
27                  //如果经过父类加载器之后，还是null，也就是说父类无法加载，那么再由自己完成加载  
28                   if (c == null) {  
29                     // If still not found, then invoke findClass in order  
30                     // to find the class.  
31                     long t1 = System.nanoTime();  
32                     c = findClass(name);//调用自己的findClass()方法  
33   
34                     // this is the defining class loader; record the stats  
35                     sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);  
36                     sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);  
37                     sun.misc.PerfCounter.getFindClasses().increment();  
38                 }  
39             }  
40             if (resolve) {  
41                 resolveClass(c);  
42             }  
43             return c;  
44         }  
45     } 

 

所以，可以很清楚的看到，加载一个类的过程，它是层层的像父类委托，然后在层层的向下加载。用这样的一种委托机制，到底有什么好处呢？为什么要这样做呢？

原因如下：

1、节约系统资源。只要，这个类已经被加载过了，就不会在次加载。

2、保证 Java 核心库的类型安全。所有 Java 应用都至少需要引用 java.lang.Object类，也就是说在运行的时候，java.lang.Object这个类需要被加载到 Java 虚拟机中。如果这个加载过程由 Java 应用自己的类加载器来完成的话，很可能就存在多个版本的 java.lang.Object类，而且这些类之间是不兼容的。通过代理模式，对于 Java 核心库的类的加载工作由引导类加载器来统一完成，保证了 Java 应用所使用的都是同一个版本的 Java 核心库的类，是互相兼容的。