Java 类加载器

类加载器基本概念

顾 名思义，类加载器（class loader）用来加载 Java 类到 Java 虚拟机中。一般来说，Java 虚拟机使用 Java 类的方式如下：Java 源程序（.java 文件）在经过 Java 编译器编译之后就被转换成 Java 字节代码（.class 文件）。类加载器负责读取 Java 字节代码，并转换成 java.lang.Class类的一个实例。每个这样的实例用来表示一个 Java 类。通过此实例的 newInstance()方法就可以创建出该类的一个对象。实际的情况可能更加复杂，比如 Java 字节代码可能是通过工具动态生成的，也可能是通过网络下载的。

基本上所有的类加载器都是 java.lang.ClassLoader类的一个实例。下面详细介绍这个 Java 类。

java.lang.ClassLoader类介绍

java.lang.ClassLoader类的基本职责就是根据一个指定的类的名称，找到或者生成其对应的字节代码，然后从这些字节代码中定义出一个 Java 类，即 java.lang.Class类的一个实例。

ClassLoader提供了一系列的方法，比较重要的方法如：
 
方法说明
getParent() 返回该类加载器的父类加载器。
loadClass(String name) 加载名称为 name的类，返回的结果是 java.lang.Class类的实例。
findClass(String name) 查找名称为 name的类，返回的结果是 java.lang.Class类的实例。
findLoadedClass(String name) 查找名称为 name的已经被加载过的类，返回的结果是 java.lang.Class类的实例。
defineClass(String name, byte[] b, int off, int len) 把字节数组 b中的内容转换成 Java 类，返回的结果是 java.lang.Class类的实例。这个方法被声明为 final的。
resolveClass(Class c) 链接指定的 Java 类。
 

类加载器的树状组织结构

Java 中的类加载器大致可以分成两类，一类是系统提供的，另外一类则是由 Java 应用开发人员编写的。系统提供的类加载器主要有下面三个：

  • 引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码来实现的，并不继承自java.lang.ClassLoader。
  • 扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。
  • 系 统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader()来获取它。

除了系统提供的类加载器以外，开发人员可以通过继承 java.lang.ClassLoader类的方式实现自己的类加载器，以满足一些特殊的需求。

除 了引导类加载器之外，所有的类加载器都有一个父类加载器。通过 上面表中给出的 getParent()方法可以得到。对于系统提供的类加载器来说，系统类加载器的父类加载器是扩展类加载器，而扩展类加载器的父类加载 器是引导类加载器；对于开发人员编写的类加载器来说，其父类加载器是加载此类加载器 Java 类的类加载器。因为类加载器 Java 类如同其它的 Java 类一样，也是要由类加载器来加载的。一般来说，开发人员编写的类加载器的父类加载器是系统类加载器。类加载器通过这种方式组织起来，形成树状结构。树的根 节点就是引导类加载器。下图中给出了一个典型的类加载器树状组织结构示意图，其中的箭头指向的是父类加载器。

 类加载器树状组织结构示意图 类加载器树状组织结构示意图 

下面代码演示了类加载器的树状组织结构。

清单 1. 演示类加载器的树状组织结构
  1. public class ClassLoaderTree {
  3.     public static void main(String[] args) {
  4.         ClassLoader loader = ClassLoaderTree.class.getClassLoader();
  5.         while (loader != null) {
  6.             System.out.println(loader.toString());
  7.             loader = loader.getParent();
  8.         }
  9.     }
  10.  }

输出：

  1. sun.misc.Launcher$AppClassLoader@9304b1
  2. sun.misc.Launcher$ExtClassLoader@190d11

类加载器的代理模式

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

清单 3. com.example.Sample 类
  1. package com.example;
  3.  public class Sample {
  4.     private Sample instance;
  6.     public void setSample(Object instance) {
  7.         this.instance = (Sample) instance;
  8.     }
  9.  }

com.example.Sample类的方法 setSample接受一个 java.lang.Object类型的参数，并且会把该参数强制转换成com.example.Sample类型。测试 Java 类是否相同的代码如 下面代码所示。

清单 4. 测试 Java 类是否相同
  1. public void testClassIdentity() {
  2.     String classDataRootPath = "C:\\workspace\\Classloader\\classData";
  3.     FileSystemClassLoader fscl1 = new FileSystemClassLoader(classDataRootPath);
  4.     FileSystemClassLoader fscl2 = new FileSystemClassLoader(classDataRootPath);
  5.     String className = "com.example.Sample";     
  6.     try {
  7.         Class<?> class1 = fscl1.loadClass(className);
  8.         Object obj1 = class1.newInstance();
  9.         Class<?> class2 = fscl2.loadClass(className);
  10.         Object obj2 = class2.newInstance();
  11.         Method setSampleMethod = class1.getMethod("setSample", java.lang.Object.class);
  12.         setSampleMethod.invoke(obj1, obj2);
  13.     } catch (Exception e) {
  14.         e.printStackTrace();
  15.     }
  16.  }

上 面代码使用了类 FileSystemClassLoader的两个不同实例来分别加载类 com.example.Sample，得到了两个不同的 java.lang.Class的实例，接着通过 newInstance()方法分别生成了两个类的对象 obj1和 obj2，最后通过 Java 的反射 API 在对象obj1上调用方法 setSample，试图把对象 obj2赋值给 obj1内部的 instance对象。运行结果如下所示。

清单 5. 测试 Java 类是否相同的运行结果
  1. java.lang.reflect.InvocationTargetException
  2. at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
  3. at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
  4. at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
  5. at java.lang.reflect.Method.invoke(Method.java:597)
  6. at classloader.ClassIdentity.testClassIdentity(ClassIdentity.java:26)
  7. at classloader.ClassIdentity.main(ClassIdentity.java:9)
  8. Caused by: java.lang.ClassCastException: com.example.Sample
  9. cannot be cast to com.example.Sample
  10. at com.example.Sample.setSample(Sample.java:7)
  11. ... 6 more

从给出的运行结果可以看到，运行时抛出了 java.lang.ClassCastException异常。虽然两个对象 obj1和 obj2的类的名字相同，但是这两个类是由不同的类加载器实例来加载的，因此不被 Java 虚拟机认为是相同的。

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

不 同的类加载器为相同名称的类创建了额外的名称空间。相同名称的类可以并存在 Java 虚拟机中，只需要用不同的类加载器来加载它们即可。不同类加载器加载的类之间是不兼容的，这就相当于在 Java 虚拟机内部创建了一个个相互隔离的 Java 类空间。这种技术在许多框架中都被用到，后面会详细介绍。

下面具体介绍类加载器加载类的详细过程。

加载类的过程

在 前面介绍类加载器的代理模式的时候，提到过类加载器会首先代理给其它类加载器来尝试加载某个类。这就意味着真正完成类的加载工作的类加载器和启动这个加载 过程的类加载器，有可能不是同一个。真正完成类的加载工作是通过调用 defineClass来实现的；而启动类的加载过程是通过调 用 loadClass来实现的。前者称为一个类的定义加载器（defining loader），后者称为初始加载器（initiating loader）。在 Java 虚拟机判断两个类是否相同的时候，使用的是类的定义加载器。也就是说，哪个类加载器启动类的加载过程并不重要，重要的是最终定义这个类的加载器。两种类加 载器的关联之处在于：一个类的定义加载器是它引用的其它类的初始加载器。如类 com.example.Outer引用了 类 com.example.Inner，则由类 com.example.Outer的定义加载器负责启动类com.example.Inner的加载 过程。

方法 loadClass()抛出的是 java.lang.ClassNotFoundException异常；方法 defineClass()抛出的是java.lang.NoClassDefFoundError异常。

类 加载器在成功加载某个类之后，会把得到的 java.lang.Class类的实例缓存起来。下次再请求加载该类的时候，类加载器会直接使用缓存的类的实 例，而不会尝试再次加载。也就是说，对于一个类加载器实例来说，相同全名的类只加载一次，即 loadClass方法不会被重复调用。

 

Class.forName

Class.forName 是一个静态方法，同样可以用来加载类。该方法有两种形式：Class.forName(String name, boolean initialize, ClassLoader loader)和 Class.forName(String className)。第一种形式的参数 name表示的是类的全名；initialize表示是否初始化类；loader表示加载时使用的类加载器。第 二种形式则相当于设置了参数 initialize的值为 true，loader的值为当前类的类加载器。Class.forName的一个很常见的用 法是在加载数据库驱动的时候。如 Class.forName("org.apache.derby.jdbc.EmbeddedDriver").newInstance()用来加载 Apache Derby 数据库的驱动。

 

开发自己的类加载器

虽 然在绝大多数情况下，系统默认提供的类加载器实现已经可以满足需求。但是在某些情况下，您还是需要为应用开发出自己的类加载器。比如您的应用通过网络来传 输 Java 类的字节代码，为了保证安全性，这些字节代码经过了加密处理。这个时候您就需要自己的类加载器来从某个网络地址上读取加密后的字节代码，接着进行解密和验 证，最后定义出要在 Java 虚拟机中运行的类来。下面将通过两个具体的实例来说明类加载器的开发。

文件系统类加载器

第一个类加载器用来加载存储在文件系统上的 Java 字节代码。完整的实现如下

 

  1. public class FileSystemClassLoader extends ClassLoader {
  3.     private String rootDir;
  5.     public FileSystemClassLoader(String rootDir) {
  6.         this.rootDir = rootDir;
  7.     }
  9.     protected Class<?> findClass(String name) throws ClassNotFoundException {
  10.         byte[] classData = getClassData(name);
  11.         if (classData == null) {
  12.             throw new ClassNotFoundException();
  13.         }
  14.         else {
  15.             return defineClass(name, classData, 0, classData.length);
  16.         }
  17.     }
  19.     private byte[] getClassData(String className) {
  20.         String path = classNameToPath(className);
  21.         try {
  22.             InputStream ins = new FileInputStream(path);
  23.             ByteArrayOutputStream baos = new ByteArrayOutputStream();
  24.             int bufferSize = 4096;
  25.             byte[] buffer = new byte[bufferSize];
  26.             int bytesNumRead = 0;
  27.             while ((bytesNumRead = ins.read(buffer)) != -1) {
  28.                 baos.write(buffer, 0, bytesNumRead);
  29.             }
  30.             return baos.toByteArray();
  31.         } catch (IOException e) {
  32.             e.printStackTrace();
  33.         }
  34.         return null;
  35.     }
  37.     private String classNameToPath(String className) {
  38.         return rootDir + File.separatorChar
  39.                 + className.replace('.', File.separatorChar) + ".class";
  40.     }
  41.  }
所示。

如上所示，类 FileSystemClassLoader继承自类 java.lang.ClassLoader。在 表 1中 列出的 java.lang.ClassLoader类的常用方法中，一般来说，自己开发的类加载器只需要覆写 findClass(String name)方法即可。java.lang.ClassLoader类的方法loadClass()封装了前面提到的代理模式的实现。该方法会首先调 用 findLoadedClass()方法来检查该类是否已经被加载过；如果没有加载过的话，会调用父类加载器的 loadClass()方法来尝试加 载该类；如果父类加载器无法加载该类的话，就调用 findClass()方法来查找该类。因此，为了保证类加载器都正确实现代理模式，在开发自己的类加 载器时，最好不要覆写 loadClass()方法，而是覆写findClass()方法。

类 FileSystemClassLoader 的 findClass()方法首先根据类的全名在硬盘上查找类的字节代码文件（.class 文件），然后读取该文件内容，最后通过 defineClass()方法来把这些字节代码转换成 java.lang.Class类的实例。

                                  

                       

             
   
 
posted @ 2016-12-18 18:14  Big_Foot  阅读(175)  评论(0)  编辑  收藏  举报