一.概述

 

定义:虚拟机把描述类的数据从Class文件加载到内存,并对数据进行校验、转换解析和初始化,最终形成可以被虚拟机直接使用的java类型。类加载和连接的过程都是在运行期间完成的。

二. 类的加载方式

 
1):本地编译好的class中直接加载
2):网络加载:java.net.URLClassLoader可以加载url指定的类
3):从jar、zip等等压缩文件加载类,自动解析jar文件找到class文件去加载util类
4):从java源代码文件动态编译成为class文件
 

三.类加载的时机

 

1. 类加载的生命周期:加载(Loading)-->验证(Verification)-->准备(Preparation)-->解析(Resolution)-->初始化(Initialization)-->使用(Using)-->卸载(Unloading)

2.加载:这有虚拟机自行决定。

3.初始化阶段:

a)遇到new、getstatic、putstatic、invokestatic这4个字节码指令时,如果类没有进行过初始化,出发初始化操作。

b)使用java.lang.reflect包的方法对类进行反射调用时。

c)当初始化一个类的时候,如果发现其父类还没有执行初始化则进行初始化。

d)虚拟机启动时用户需要指定一个需要执行的主类,虚拟机首先初始化这个主类。

注意:接口与类的初始化规则在第三点不同,接口不要气所有的父接口都进行初始化。

四.类加载的过程

 

4.1.加载

 

a)加载阶段的工作

i.通过一个类的全限定名来获取定义此类的二进制字节流。

ii.将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。

iii.在java堆中生成一个代表这个类的java.lang.Class对象,做为方法区这些数据的访问入口。

b)加载阶段完成之后二进制字节流就按照虚拟机所需的格式存储在方区去中。

 

4.2.验证

 

这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求。

a)文件格式验证:验证字节流是否符合Class文件格式的规范,并且能被当前版本的虚拟机处理。

b)元数据验证:对字节码描述的信息进行语义分析,以确保其描述的信息符合java语言规范的要求。

c)字节码验证:这个阶段的主要工作是进行数据流和控制流的分析。任务是确保被验证类的方法在运行时不会做出危害虚拟机安全的行为。

d)符号引用验证:这一阶段发生在虚拟机将符号引用转换为直接引用的时候(解析阶段),主要是对类自身以外的信息进行匹配性的校验。目的是确保解析动作能够正常执行。

4.3.准备

 

准备阶段是正式为变量分配内存并设置初始值,这些内存都将在方法区中进行分配,这里的变量仅包括类标量不包括实例变量。

4.4.解析

 

解析是虚拟机将常量池的符号引用替换为直接引用的过程。

a)符号引用:符号引用以一组符号来描述所引用的目标,符号可以是任意形式的字面量,只要使用时能无歧义地定位到目标即可。符号引用与虚拟机实现的内存布局无关,引用的目标并不一定已经加载到内存中。

b)直接引用:直接引用可以是直接指向目标的指针,相对偏移量或是一个能间接定位到目标的句柄。直接饮用是与内存布局相关的。

c)类或接口的解析

d)字段的解析

e)类方法解析

f)接口方法解析

4.5.初始化

 

是根据程序员制定的主观计划区初始化变量和其他资源,或者可以从另外一个角度来表达:初始化阶段是执行类构造器<clinit>()方法的过程。

五.JVM三种预定义类型类加载器

 

当一个 JVM 启动的时候,Java 缺省开始使用如下三种类型类装入器:

启动(Bootstrap)类加载器:引导类装入器是用本地代码实现的类装入器,它负责将 <Java_Runtime_Home>/lib 下面的类库加载到内存中。由于引导类加载器涉及到虚拟机本地实现细节,开发者无法直接获取到启动类加载器的引用,所以不允许直接通过引用进行操作。

标准扩展(Extension)类加载器:扩展类加载器是由 Sun 的 ExtClassLoader(sun.misc.Launcher$ExtClassLoader) 实现的。它负责将

< Java_Runtime_Home >/lib/ext 或者由系统变量 java.ext.dir 指定位置中的类库加载到内存中。开发者可以直接使用标准扩展类加载器。

系统(System)类加载器:系统类加载器是由 Sun 的 AppClassLoader(sun.misc.Launcher$AppClassLoader)实现的。它负责将系统类路径(CLASSPATH)中指定的类库加载到内存中。开发者可以直接使用系统类加载器。

除了以上列举的三种类加载器,还有一种比较特殊的类型就是线程上下文类加载器,这个将在后面单独介绍。

a. Bootstrap ClassLoader/启动类加载器

主要负责jdk_home/lib目录下的核心 api 或 -Xbootclasspath 选项指定的jar包装入工作.

b. Extension ClassLoader/扩展类加载器

主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作

c. System ClassLoader/系统类加载器

主要负责java -classpath/-Djava.class.path所指的目录下的类与jar包装入工作.

d. User Custom ClassLoader/用户自定义类加载器(java.lang.ClassLoader的子类)

在程序运行期间, 通过java.lang.ClassLoader的子类动态加载class文件, 体现java动态实时类装入特性.

六. 类加载双亲委派机制介绍和分析

 

在这里,需要着重说明的是,JVM在加载类时默认采用的是双亲委派机制。通俗的讲,就是某个特定的类加载器在接到加载类的请求时,首先将加载任务委托给父类加载器,依次递归,如果父类加载器可以完成类加载任务,就成功返回;只有父类加载器无法完成此加载任务时,才自己去加载。关于虚拟机默认的双亲委派机制,我们可以从系统类加载器和标准扩展类加载器为例作简单分析。


图一 标准扩展类加载器继承层次图

图二 系统类加载器继承层次图

通过图一和图二我们可以看出,类加载器均是继承自java.lang.ClassLoader抽象类。我们下面我们就看简要介绍一下java.lang.ClassLoader中几个最重要的方法:

  1. //加载指定名称(包括包名)的二进制类型,供用户调用的接口
  2. public Class<?> loadClass(String name) throws ClassNotFoundException{//…}
  3. //加载指定名称(包括包名)的二进制类型,同时指定是否解析(但是,这里的resolve参数不一定真正能达到解析的效果~_~),供继承用
  4. protectedsynchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException{//…}
  5. //findClass方法一般被loadClass方法调用去加载指定名称类,供继承用
  6. protected Class<?> findClass(String name) throws ClassNotFoundException {//…}
  7. //定义类型,一般在findClass方法中读取到对应字节码后调用,可以看出不可继承(说明:JVM已经实现了对应的具体功能,解析对应的字节码,产生对应的内部数据结构放置到方法区,所以无需覆写,直接调用就可以了)
  8. protected final Class<?> defineClass(String name, byte[] b, int off, int len)
  9. throws ClassFormatError{//…}

通过进一步分析标准扩展类加载器(sun.misc.Launcher$ExtClassLoader)和系统类加载器(sun.misc.Launcher$AppClassLoader)的代码以及其公共父类(java.net.URLClassLoader和java.security.SecureClassLoader)的代码可以看出,都没有覆写java.lang.ClassLoader中默认的加载委派规则---loadClass(…)方法。既然这样,我们就可以通过分析java.lang.ClassLoader中的loadClass(String name)方法的代码就可以分析出虚拟机默认采用的双亲委派机制到底是什么模样:

  1. public Class<?> loadClass(String name)throws ClassNotFoundException {
  2. return loadClass(name,false);
  3. }
  4. protectedsynchronized Class<?> loadClass(String name,boolean resolve)
  5. throws ClassNotFoundException {
  6. //首先判断该类型是否已经被加载
  7. Class c = findLoadedClass(name);
  8. if (c ==null) {
  9. //如果没有被加载,就委托给父类加载或者委派给启动类加载器加载
  10. try {
  11. if (parent !=null) {
  12. //如果存在父类加载器,就委派给父类加载器加载
  13. c = parent.loadClass(name,false);
  14. }else {
  15. //如果不存在父类加载器,就检查是否是由启动类加载器加载的类,通过调用本地方法native Class findBootstrapClass(String name)
  16. c = findBootstrapClass0(name);
  17. }
  18. }catch (ClassNotFoundException e) {
  19. //如果父类加载器和启动类加载器都不能完成加载任务,才调用自身的加载功能
  20. c = findClass(name);
  21. }
  22. }
  23. if (resolve) {
  24. resolveClass(c);
  25. }
  26. return c;
  27. }

通过上面的代码分析,我们可以对JVM采用的双亲委派类加载机制有了更感性的认识,下面我们就接着分析一下启动类加载器、标准扩展类加载器和系统类加载器三者之间的关系。可能大家已经从各种资料上面看到了如下类似的一幅图片:

图三 类加载器默认委派关系图

上面图片给人的直观印象是系统类加载器的父类加载器是标准扩展类加载器,标准扩展类加载器的父类加载器是启动类加载器,下面我们就用代码具体测试一下:

示例代码:

  1. public static void main(String[] args) {
  2. try {
  3. System.out.println(ClassLoader.getSystemClassLoader());
  4. System.out.println(ClassLoader.getSystemClassLoader().getParent();
  5. System.out.println(ClassLoader.getSystemClassLoader().getParent().getParent());
  6. } catch (Exception e) {
  7. e.printStackTrace();
  8. }
  9. }

说明:通过java.lang.ClassLoader.getSystemClassLoader()可以直接获取到系统类加载器。

  1. 代码输出如下:
  2. sun.misc.Launcher$AppClassLoader@197d257
  3. sun.misc.Launcher$ExtClassLoader@7259da
  4. null

通过以上的代码输出,我们可以判定系统类加载器的父加载器是标准扩展类加载器,但是我们试图获取标准扩展类加载器的父类加载器时确得到了null,就是说标准扩展类加载器本身强制设定父类加载器为null。我们还是借助于代码分析一下:

我们首先看一下java.lang.ClassLoader抽象类中默认实现的两个构造函数:

  1. protected ClassLoader() {
  2. SecurityManager security = System.getSecurityManager();
  3. if (security !=null) {
  4. security.checkCreateClassLoader();
  5. }
  6. //默认将父类加载器设置为系统类加载器,getSystemClassLoader()获取系统类加载器
  7. this.parent = getSystemClassLoader();
  8. initialized =true;
  9. }
  10. protected ClassLoader(ClassLoader parent) {
  11. SecurityManager security = System.getSecurityManager();
  12. if (security !=null) {
  13. security.checkCreateClassLoader();
  14. }
  15. //强制设置父类加载器
  16. this.parent = parent;
  17. initialized =true;
  18. }

我们再看一下ClassLoader抽象类中parent成员的声明:

  1. // The parent class loader for delegation
  2. e ClassLoaderparent;

声明为私有变量的同时并没有对外提供可供派生类访问的public或者protected设置器接口(对应的setter方法),结合前面的测试代码的输出,我们可以推断出

1.系统类加载器(AppClassLoader)调用ClassLoader(ClassLoader parent)构造函数将父类加载器设置为标准扩展类加载器(ExtClassLoader)。(因为如果不强制设置,默认会通过调用getSystemClassLoader()方法获取并设置成系统类加载器,这显然和测试输出结果不符。)

2.扩展类加载器(ExtClassLoader)调用ClassLoader(ClassLoader parent)构造函数将父类加载器设置为null。(因为如果不强制设置,默认会通过调用getSystemClassLoader()方法获取并设置成系统类加载器,这显然和测试输出结果不符。)

现在我们可能会有这样的疑问:扩展类加载器(ExtClassLoader)的父类加载器被强制设置为null了,那么扩展类加载器为什么还能将加载任务委派给启动类加载器呢?

图四 标准扩展类加载器和系统类加载器成员大纲视图


图五扩展类加载器和系统类加载器公共父类成员大纲视图

通过图四和图五可以看出,标准扩展类加载器和系统类加载器及其父类(java.net.URLClassLoader和java.security.SecureClassLoader)都没有覆写java.lang.ClassLoader中默认的加载委派规则---loadClass(…)方法。有关java.lang.ClassLoader中默认的加载委派规则前面已经分析过,如果父加载器为null,则会调用本地方法进行启动类加载尝试。所以,图三中,启动类加载器、标准扩展类加载器和系统类加载器之间的委派关系事实上是仍就成立的。(在后面的用户自定义类加载器部分,还会做更深入的分析)。

七. 类加载双亲委派示例

 

以上已经简要介绍了虚拟机默认使用的启动类加载器、标准扩展类加载器和系统类加载器,并以三者为例结合JDK代码对JVM默认使用的双亲委派类加载机制做了分析。下面我们就来看一个综合的例子。首先在eclipse中建立一个简单的java应用工程,然后写一个简单的JavaBean如下:

  1. package classloader.test.bean;
  2. publicclass TestBean {
  3. public TestBean() {}
  4. }

在现有当前工程中另外建立一测试类(ClassLoaderTest.java)内容如下:

测试一:

  1. publicclass ClassLoaderTest {
  2. publicstaticvoid main(String[] args) {
  3. try {
  4. //查看当前系统类路径中包含的路径条目
  5. System.out.println(System.getProperty("java.class.path"));
  6. //调用加载当前类的类加载器(这里即为系统类加载器)加载TestBean
  7. Class typeLoaded = Class.forName("classloader.test.bean.TestBean");
  8. //查看被加载的TestBean类型是被那个类加载器加载的
  9. System.out.println(typeLoaded.getClassLoader());
  10. }catch (Exception e) {
  11. e.printStackTrace();
  12. }
  13. }
  14. }

对应的输出如下:

  1. D:"DEMO"dev"Study"ClassLoaderTest"bin
  2. sun.misc.Launcher$AppClassLoader@197d257

(说明:当前类路径默认的含有的一个条目就是工程的输出目录)

测试二:

将当前工程输出目录下的…/classloader/test/bean/TestBean.class打包进test.jar剪贴到< Java_Runtime_Home >/lib/ext目录下(现在工程输出目录下和JRE扩展目录下都有待加载类型的class文件)。再运行测试测试代码,结果如下:

  1. D:"DEMO"dev"Study"ClassLoaderTest"bin
  2. sun.misc.Launcher$ExtClassLoader@7259da

对比测试一和测试二,我们明显可以验证前面说的双亲委派机制,系统类加载器在接到加载classloader.test.bean.TestBean类型的请求时,首先将请求委派给父类加载器(标准扩展类加载器),标准扩展类加载器抢先完成了加载请求。

测试三:

test.jar拷贝一份到< Java_Runtime_Home >/lib下,运行测试代码,输出如下:

  1. D:"DEMO"dev"Study"ClassLoaderTest"bin
  2. sun.misc.Launcher$ExtClassLoader@7259da

测试三和测试二输出结果一致。那就是说,放置到< Java_Runtime_Home >/lib目录下的TestBean对应的class字节码并没有被加载,这其实和前面讲的双亲委派机制并不矛盾。虚拟机出于安全等因素考虑,不会加载< Java_Runtime_Home >/lib存在的陌生类开发者通过将要加载的非JDK自身的类放置到此目录下期待启动类加载器加载是不可能的。做个进一步验证,删除< Java_Runtime_Home >/lib/ext目录下和工程输出目录下的TestBean对应的class文件,然后再运行测试代码,则将会有ClassNotFoundException异常抛出。有关这个问题,大家可以在java.lang.ClassLoader中的loadClass(String name, boolean resolve)方法中设置相应断点运行测试三进行调试,会发现findBootstrapClass0()会抛出异常,然后在下面的findClass方法中被加载,当前运行的类加载器正是扩展类加载器(sun.misc.Launcher$ExtClassLoader),这一点可以通过JDT中变量视图查看验证。

八. 程序动态扩展方式

 

Java的连接模型允许用户运行时扩展引用程序,既可以通过当前虚拟机中预定义的加载器加载编译时已知的类或者接口,又允许用户自行定义类装载器,在运行时动态扩展用户的程序。通过用户自定义的类装载器,你的程序可以装载在编译时并不知道或者尚未存在的类或者接口,并动态连接它们并进行有选择的解析。

运行时动态扩展java应用程序有如下两个途径:

8.1.调用java.lang.Class.forName(…)

 

这个方法其实在前面已经讨论过,在后面的问题2解答中说明了该方法调用会触发那个类加载器开始加载任务。这里需要说明的是多参数版本的forName(…)方法:

  1. public static Class<?> forName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException

这里的initialize参数是很重要的,可以觉得被加载同时是否完成初始化的工作(说明: 单参数版本的forName方法默认是不完成初始化的).有些场景下,需要将initialize设置为true来强制加载同时完成初始化,例如典型的就是利用DriverManager进行JDBC驱动程序类注册的问题,因为每一个JDBC驱动程序类的静态初始化方法都用DriverManager注册驱动程序,这样才能被应用程序使用,这就要求驱动程序类必须被初始化,而不单单被加载.

8.2.用户自定义类加载器

 

通过前面的分析,我们可以看出,除了和本地实现密切相关的启动类加载器之外,包括标准扩展类加载器和系统类加载器在内的所有其他类加载器我们都可以当做自定义类加载器来对待,唯一区别是是否被虚拟机默认使用。前面的内容中已经对java.lang.ClassLoader抽象类中的几个重要的方法做了介绍,这里就简要叙述一下一般用户自定义类加载器的工作流程吧(可以结合后面问题解答一起看):

1、首先检查请求的类型是否已经被这个类装载器装载到命名空间中了,如果已经装载,直接返回;否则转入步骤2

2、委派类加载请求给父类加载器(更准确的说应该是双亲类加载器,真个虚拟机中各种类加载器最终会呈现树状结构),如果父类加载器能够完成,则返回父类加载器加载的Class实例;否则转入步骤3

3、调用本类加载器的findClass(…)方法,试图获取对应的字节码,如果获取的到,则调用defineClass(…)导入类型到方法区;如果获取不到对应的字节码或者其他原因失败,返回异常给loadClass(…), loadClass(…)转抛异常,终止加载过程(注意:这里的异常种类不止一种)。

(说明:这里说的自定义类加载器是指JDK 1.2以后版本的写法,即不覆写改变java.lang.loadClass(…)已有委派逻辑情况下)

九. 常见问题分析

 

9.1.由不同的类加载器加载的指定类型还是相同的类型吗?

 

在Java中,一个类用其完全匹配类名(fully qualified class name)作为标识,这里指的完全匹配类名包括包名和类名。但在JVM中一个类用其全名和一个加载类ClassLoader的实例作为唯一标识,不同类加载器加载的类将被置于不同的命名空间.我们可以用两个自定义类加载器去加载某自定义类型(注意,不要将自定义类型的字节码放置到系统路径或者扩展路径中,否则会被系统类加载器或扩展类加载器抢先加载),然后用获取到的两个Class实例进行java.lang.Object.equals(…)判断,将会得到不相等的结果。这个大家可以写两个自定义的类加载器去加载相同的自定义类型,然后做个判断;同时,可以测试加载java.*类型,然后再对比测试一下测试结果。

9.2.在代码中直接调用Class.forName(String name)方法,到底会触发那个类加载器进行类加载行为?

 

Class.forName(String name)默认会使用调用类的类加载器来进行类加载。我们直接来分析一下对应的jdk的代码:

  1. //java.lang.Class.java
  2. publicstatic Class<?>forName(String className)throws ClassNotFoundException {
  3. return forName0(className,true, ClassLoader.getCallerClassLoader());
  4. }
  5. //java.lang.ClassLoader.java
  6. // Returns the invoker's class loader, or null if none.
  7. static ClassLoader getCallerClassLoader() {
  8. // 获取调用类(caller)的类型
  9. Class caller = Reflection.getCallerClass(3);
  10. // This can be null if the VM is requesting it
  11. if (caller ==null) {
  12. returnnull;
  13. }
  14. //调用java.lang.Class中本地方法获取加载该调用类(caller)的ClassLoader
  15. return caller.getClassLoader0();
  16. }
  17. //java.lang.Class.java
  18. //虚拟机本地实现,获取当前类的类加载器,前面介绍的Class的getClassLoader()也使用此方法
  19. native ClassLoader getClassLoader0();

9.3.在编写自定义类加载器时,如果没有设定父加载器,那么父加载器是?

 

前面讲过,在不指定父类加载器的情况下,默认采用系统类加载器。可能有人觉得不明白,现在我们来看一下JDK对应的代码实现。众所周知,我们编写自定义的类加载器直接或者间接继承自java.lang.ClassLoader抽象类,对应的无参默认构造函数实现如下:

  1. //摘自java.lang.ClassLoader.java
  2. protected ClassLoader() {
  3. SecurityManager security = System.getSecurityManager();
  4. if (security !=null) {
  5. security.checkCreateClassLoader();
  6. }
  7. this.parent = getSystemClassLoader();
  8. initialized =true;
  9. }

我们再来看一下对应的getSystemClassLoader()方法的实现:

  1. privatestaticsynchronizedvoid initSystemClassLoader() {
  2. //...
  3. sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
  4. scl = l.getClassLoader();
  5. //...
  6. }

我们可以写简单的测试代码来测试一下:

  1. System.out.println(sun.misc.Launcher.getLauncher().getClassLoader());

本机对应输出如下:

  1. sun.misc.Launcher$AppClassLoader@197d257

所以,我们现在可以相信当自定义类加载器没有指定父类加载器的情况下,默认的父类加载器即为系统类加载器。同时,我们可以得出如下结论:

即时用户自定义类加载器不指定父类加载器,那么,同样可以加载如下三个地方的类:

1.<Java_Runtime_Home>/lib下的类

2.< Java_Runtime_Home >/lib/ext下或者由系统变量java.ext.dir指定位置中的类

3.当前工程类路径下或者由系统变量java.class.path指定位置中的类

9.4.在编写自定义类加载器时,如果将父类加载器强制设置为null,那么会有什么影响?如果自定义的类加载器不能加载指定类,就肯定会加载失败吗?

 

JVM规范中规定如果用户自定义的类加载器将父类加载器强制设置为null,那么会自动将启动类加载器设置为当前用户自定义类加载器的父类加载器(这个问题前面已经分析过了)。同时,我们可以得出如下结论:

即时用户自定义类加载器不指定父类加载器,那么,同样可以加载到<Java_Runtime_Home>/lib下的类,但此时就不能够加载<Java_Runtime_Home>/lib/ext目录下的类了。

说明:问题3和问题4的推断结论是基于用户自定义的类加载器本身延续了java.lang.ClassLoader.loadClass(…)默认委派逻辑,如果用户对这一默认委派逻辑进行了改变,以上推断结论就不一定成立了,详见问题5。

 

9.5.编写自定义类加载器时,一般有哪些注意点?

 

9.5.1.一般尽量不要覆写已有的loadClass(…)方法中的委派逻辑

 

一般在JDK 1.2之前的版本才这样做,而且事实证明,这样做极有可能引起系统默认的类加载器不能正常工作。在JVM规范和JDK文档中(1.2或者以后版本中),都没有建议用户覆写loadClass(…)方法,相比而言,明确提示开发者在开发自定义的类加载器时覆写findClass(…)逻辑。举一个例子来验证该问题:

  1. //用户自定义类加载器WrongClassLoader.Java(覆写loadClass逻辑)
  2. publicclassWrongClassLoaderextends ClassLoader {
  3. public Class<?> loadClass(String name)throws ClassNotFoundException {
  4. returnthis.findClass(name);
  5. }
  6. protected Class<?> findClass(String name)throws ClassNotFoundException {
  7. //假设此处只是到工程以外的特定目录D:/library下去加载类
  8. 具体实现代码省略
  9. }
  10. }

通过前面的分析我们已经知道,用户自定义类加载器(WrongClassLoader)的默

认的类加载器是系统类加载器,但是现在问题4种的结论就不成立了。大家可以简

单测试一下,现在<Java_Runtime_Home>/lib、< Java_Runtime_Home >/lib/ext和工

程类路径上的类都加载不上了。

  1. //问题5测试代码一
  2. publicclass WrongClassLoaderTest {
  3. publicstaticvoid main(String[] args) {
  4. try {
  5. WrongClassLoader loader =new WrongClassLoader();
  6. Class classLoaded = loader.loadClass("beans.Account");
  7. System.out.println(classLoaded.getName());
  8. System.out.println(classLoaded.getClassLoader());
  9. }catch (Exception e) {
  10. e.printStackTrace();
  11. }
  12. }
  13. }

(说明:D:"classes"beans"Account.class物理存在的)

输出结果:

  1. java.io.FileNotFoundException: D:"classes"java"lang"Object.class (系统找不到指定的路径。)
  2. at java.io.FileInputStream.open(Native Method)
  3. at java.io.FileInputStream.<init>(FileInputStream.java:106)
  4. at WrongClassLoader.findClass(WrongClassLoader.java:40)
  5. at WrongClassLoader.loadClass(WrongClassLoader.java:29)
  6. at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:319)
  7. at java.lang.ClassLoader.defineClass1(Native Method)
  8. at java.lang.ClassLoader.defineClass(ClassLoader.java:620)
  9. at java.lang.ClassLoader.defineClass(ClassLoader.java:400)
  10. at WrongClassLoader.findClass(WrongClassLoader.java:43)
  11. at WrongClassLoader.loadClass(WrongClassLoader.java:29)
  12. at WrongClassLoaderTest.main(WrongClassLoaderTest.java:27)
  13. Exception in thread "main" java.lang.NoClassDefFoundError: java/lang/Object
  14. at java.lang.ClassLoader.defineClass1(Native Method)
  15. at java.lang.ClassLoader.defineClass(ClassLoader.java:620)
  16. at java.lang.ClassLoader.defineClass(ClassLoader.java:400)
  17. at WrongClassLoader.findClass(WrongClassLoader.java:43)
  18. at WrongClassLoader.loadClass(WrongClassLoader.java:29)
  19. at WrongClassLoaderTest.main(WrongClassLoaderTest.java:27)

这说明,连要加载的类型的超类型java.lang.Object都加载不到了。这里列举的由于覆写loadClass(…)引起的逻辑错误明显是比较简单的,实际引起的逻辑错误可能复杂的多。

  1. //问题5测试二
  2. //用户自定义类加载器WrongClassLoader.Java(不覆写loadClass逻辑)
  3. publicclassWrongClassLoaderextends ClassLoader {
  4. protected Class<?> findClass(String name)throws ClassNotFoundException {
  5. //假设此处只是到工程以外的特定目录D:/library下去加载类
  6. 具体实现代码省略
  7. }
  8. }

将自定义类加载器代码WrongClassLoader.Java做以上修改后,再运行测试代码,输出结果如下:

  1. beans.Account
  2. WrongClassLoader@1c78e57

这说明,beans.Account加载成功,且是由自定义类加载器WrongClassLoader加载。

这其中的原因分析,我想这里就不必解释了,大家应该可以分析的出来了。

9.5.2.正确设置父类加载器

 

通过上面问题4和问题5的分析我们应该已经理解,个人觉得这是自定义用户类加载器时最重要的一点,但常常被忽略或者轻易带过。有了前面JDK代码的分析作为基础,我想现在大家都可以随便举出例子了。

9.5.3.保证findClass(String)方法的逻辑正确性

 

事先尽量准确理解待定义的类加载器要完成的加载任务,确保最大程度上能够获取到对应的字节码内容。

9.6.如何在运行时判断系统类加载器能加载哪些路径下的类?

 

一是可以直接调用ClassLoader.getSystemClassLoader()或者其他方式获取到系统类加载器(系统类加载器和扩展类加载器本身都派生自URLClassLoader),调用URLClassLoader中的getURLs()方法可以获取到;

二是可以直接通过获取系统属性java.class.path 来查看当前类路径上的条目信息 , System.getProperty("java.class.path")

9.7.如何在运行时判断标准扩展类加载器能加载哪些路径下的类?

 

方法之一:

  1. try {
  2. URL[] extURLs = ((URLClassLoader)ClassLoader.getSystemClassLoader().getParent()).getURLs();
  3. for (int i = 0; i < extURLs.length; i++) {
  4. System.out.println(extURLs[i]);
  5. }
  6. } catch (Exception e) {//…}

本机对应输出如下:

  1. file:/D:/DEMO/jdk1.5.0_09/jre/lib/ext/dnsns.jar
  2. file:/D:/DEMO/jdk1.5.0_09/jre/lib/ext/localedata.jar
  3. file:/D:/DEMO/jdk1.5.0_09/jre/lib/ext/sunjce_provider.jar
  4. file:/D:/DEMO/jdk1.5.0_09/jre/lib/ext/sunpkcs11.jar

十、再分析类加载

 

10.1.类加载器的特性

 

1,每个ClassLoader都维护了一份自己的名称空间,同一个名称空间里不能出现两个同名的类。
2,为了实现java安全沙箱模型顶层的类加载器安全机制, java默认采用了”双亲委派的加载链”结构.

如下图:

Class Diagram:

类图中,BootstrapClassLoader是一个单独的java类,其实在这里,不应该叫他是一个java类。
因为,它已经完全不用java实现了。

它是在jvm启动时,就被构造起来的,负责java平台核心库。(具体上面已经有介绍)

启动类加载实现(其实我们不用关心这块,但是有兴趣的,可以研究一下):
bootstrap classLoader类加载原理探索

10.2.自定义类加载器加载一个类的步骤

ClassLoader类加载逻辑分析,以下逻辑是除BootstrapClassLoader外的类加载器加载流程:

  1. // 检查类是否已被装载过
  2. Class c = findLoadedClass(name);
  3. if (c == null ) {
  4. // 指定类未被装载过
  5. try {
  6. if (parent != null ) {
  7. // 如果父类加载器不为空, 则委派给父类加载
  8. c = parent.loadClass(name, false );
  9. } else {
  10. // 如果父类加载器为空, 则委派给启动类加载加载
  11. c = findBootstrapClass0(name);
  12. }
  13. } catch (ClassNotFoundException e) {
  14. // 启动类加载器或父类加载器抛出异常后, 当前类加载器将其
  15. // 捕获, 并通过findClass方法, 由自身加载
  16. c = findClass(name);
  17. }
  18. }

10.3.用Class.forName加载类

 

Class.forName使用的是被调用者的类加载器来加载类的.
这种特性,证明了java类加载器中的名称空间是唯一的,不会相互干扰.

即在一般情况下,保证同一个类中所关联的其他类都是由当前类的类加载器所加载的.

  1. public static Class forName(String className)
  2. throws ClassNotFoundException {
  3. return forName0(className, true , ClassLoader.getCallerClassLoader());
  4. }
  5. /** Called after security checks have been made. */
  6. private static native Class forName0(String name, boolean initialize,
  7. ClassLoader loader)
  8. throws ClassNotFoundException;

上图中ClassLoader.getCallerClassLoader就是得到调用当前forName方法的类的类加载器

10.4.线程上下文类加载器

 

java默认的线程上下文类加载器是系统类加载器(AppClassLoader).

  1. // Now create the class loader to use to launch the application
  2. try {
  3. loader = AppClassLoader.getAppClassLoader(extcl);
  4. } catch (IOException e) {
  5. throw new InternalError(
  6. "Could not create application class loader" );
  7. }
  8. // Also set the context class loader for the primordial thread.
  9. Thread.currentThread().setContextClassLoader(loader);

以上代码摘自sun.misc.Launch的无参构造函数Launch()。

使用线程上下文类加载器,可以在执行线程中,抛弃双亲委派加载链模式,使用线程上下文里的类加载器加载类.


典型的例子有,通过线程上下文来加载第三方库jndi实现,而不依赖于双亲委派.

大部分java app服务器(jboss, tomcat..)也是采用contextClassLoader来处理web服务。

还有一些采用hotswap特性的框架,也使用了线程上下文类加载器,比如seasar (full stack framework in japenese).

线程上下文从根本解决了一般应用不能违背双亲委派模式的问题.

使java类加载体系显得更灵活.

随着多核时代的来临,相信多线程开发将会越来越多地进入程序员的实际编码过程中.因此,
在编写基础设施时,通过使用线程上下文来加载类,应该是一个很好的选择.

当然,好东西都有利弊.使用线程上下文加载类,也要注意,保证多根需要通信的线程间的类加载器应该是同一个,
防止因为不同的类加载器,导致类型转换异常(ClassCastException).

10.5.自定义的类加载器实现

 

defineClass(String name, byte[] b, int off, int len,ProtectionDomain protectionDomain)
是java.lang.Classloader提供给开发人员,用来自定义加载class的接口.

使用该接口,可以动态的加载class文件.

例如,
在jdk中, URLClassLoader是配合findClass方法来使用defineClass,可以从网络或硬盘上加载class.

而使用类加载接口,并加上自己的实现逻辑,还可以定制出更多的高级特性.

比如,

一个简单的hot swap类加载器实现:

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.lang.reflect.Method;
  4. import java.net.URL;
  5. import java.net.URLClassLoader;
  6. /**
  7. * 可以重新载入同名类的类加载器实现
  8. *
  9. * 放弃了双亲委派的加载链模式.
  10. * 需要外部维护重载后的类的成员变量状态.
  11. *
  12. * @author ken.wu
  13. * @mail ken.wug@gmail.com
  14. * 2007-9-28 下午01:37:43
  15. */
  16. public class HotSwapClassLoader extends URLClassLoader {
  17. public HotSwapClassLoader(URL[] urls) {
  18. super (urls);
  19. }
  20. public HotSwapClassLoader(URL[] urls, ClassLoader parent) {
  21. super (urls, parent);
  22. }
  23. public Class load(String name)
  24. throws ClassNotFoundException {
  25. return load(name, false );
  26. }
  27. public Class load(String name, boolean resolve)
  28. throws ClassNotFoundException {
  29. if ( null != super .findLoadedClass(name))
  30. return reload(name, resolve);
  31. Class clazz = super .findClass(name);
  32. if (resolve)
  33. super .resolveClass(clazz);
  34. return clazz;
  35. }
  36. public Class reload(String name, boolean resolve)
  37. throws ClassNotFoundException {
  38. return new HotSwapClassLoader( super .getURLs(), super .getParent()).load(
  39. name, resolve);
  40. }
  41. }
  42. public class A {
  43. private B b;
  44. public void setB(B b) {
  45. this .b = b;
  46. }
  47. public B getB() {
  48. return b;
  49. }
  50. }
  51. public class B {}

这个类的作用是可以重新载入同名的类,但是,为了实现hotswap,老的对象状态
需要通过其他方式拷贝到重载过的类生成的全新实例中来。(A类中的b实例)

而新实例所依赖的B类如果与老对象不是同一个类加载器加载的,将会抛出类型转换异常(ClassCastException).

为了解决这种问题,HotSwapClassLoader自定义了load方法.即当前类是由自身classLoader加载的,而内部依赖的类

还是老对象的classLoader加载的.

  1. public class TestHotSwap {
  2. public static void main(String args[]) {
  3. A a = new A();
  4. B b = new B();
  5. a.setB(b);
  6. System.out.printf("A classLoader is %s n" , a.getClass().getClassLoader());
  7. System.out.printf("B classLoader is %s n" , b.getClass().getClassLoader());
  8. System.out.printf("A.b classLoader is %s n" ,   a.getB().getClass().getClassLoader());
  9. HotSwapClassLoader c1 = new HotSwapClassLoader( new URL[]{ new URL( "file:\e:\test\")} , a.getClass().getClassLoader());
  10. Class clazz = c1.load(" test.hotswap.A ");
  11. Object aInstance = clazz.newInstance();
  12. Method method1 = clazz.getMethod(" setB ", B.class);
  13. method1.invoke(aInstance, b);
  14. Method method2 = clazz.getMethod(" getB ", null);
  15. Object bInstance = method2.invoke(aInstance, null);
  16. System.out.printf(" reloaded A.b classLoader is %s n", bInstance.getClass().getClassLoader());
  17. }
  18. }

输出

  1. A classLoader is sun.misc.Launcher$AppClassLoader@19821f
  2. B classLoader is sun.misc.Launcher$AppClassLoader@19821f
  3. A.b classLoader is sun.misc.Launcher$AppClassLoader@19821f
  4. reloaded A.b classLoader is sun.misc.Launcher$AppClassLoader@19821f
 
 
文章转自:http://lovnet.iteye.com/blog/1825322
 

深入JVM系列(三)之类加载、类加载器、双亲委派机制与常见问题的更多相关文章

  1. java类加载过程以及双亲委派机制

    前言:最近两个月公司实行了996上班制,加上了熬了两个通宵上线,状态很不好,头疼.牙疼,一直没有时间和精力写博客,也害怕在这样的状态下写出来的东西出错.为了不让自己荒废学习的劲头和习惯,今天周日,也打 ...

  2. 【Java_基础】java类加载过程与双亲委派机制

    1.类的加载.连接和初始化 当程序使用某个类时,如果该类还未被加载到内存中,则系统会通过加载.连接.初始化三个步骤来对类进行初始化.如果没有意外,jvm将会连续完成这三个步骤,有时也把这三个步骤统称为 ...

  3. jvm系列(三):GC算法 垃圾收集器

    原文出处:纯洁的微笑 这篇文件将给大家介绍GC都有哪几种算法,以及JVM都有那些垃圾回收器,它们的工作原理. 概述 垃圾收集 Garbage Collection 通常被称为"GC" ...

  4. JVM 系列(一)类加载

    JVM 系列(一)类加载 类加载机制是指把 class 文件加载到内存,并对数据进行校验.解析和初始化,最终形成 JVM 可以直接使用的 Java 类型的过程. ClassLoader 加载一个 cl ...

  5. JVM之类加载器、加载过程及双亲委派机制

    JVM 的生命周期 虚拟机的启动 Java 虚拟机的启动是通过引导类加载器(bootstrap class loader)创建一个初始类(initial class)来完成的,这个类是由虚拟机的具体实 ...

  6. JVM学习六:JVM之类加载器之双亲委派机制

    前面我们知道类加载有系统自带的3种加载器,也有自定义的加载器,那么这些加载器之间的关系是什么,已经在加载类的时候,谁去加载呢?这节,我们将进行讲解. 一.双亲委派机制 JVM的ClassLoader采 ...

  7. JVM总括四-类加载过程、双亲委派模型、对象实例化过程

    JVM总括四-类加载过程.双亲委派模型.对象实例化过程 目录:JVM总括:目录 一. 类加载过程 类加载过程就是将.class文件转化为Class对象,类实例化的过程,(User user = new ...

  8. Java虚拟机类加载器及双亲委派机制

    所谓的类加载器(Class Loader)就是加载Java类到Java虚拟机中的,前面<面试官,不要再问我"Java虚拟机类加载机制"了>中已经介绍了具体加载class ...

  9. JVM类加载与双亲委派机制被打破

    前言 前文已经讲了虚拟机将java文件编译成class文件后的格式:JVM虚拟机Class类文件研究分析 java文件经过编译,形成class文件,那么虚拟机如何将这些Class文件读取到内存中呢? ...

随机推荐

  1. AJAX使用技巧:如何处理书签和翻页按扭

    本篇文章提供了一个开源JavaScript库,它提供了给AJAX应用程序中添加书签和会退按钮的功能.在学习完这个教程后,开发者将能够对开发AJAX应用碰到的问题获得一个解决方案,这个特性甚至Googl ...

  2. 与众不同 windows phone (38) - 8.0 关联启动: 使用外部程序打开一个文件或URI, 关联指定的文件类型或协议

    [源码下载] 与众不同 windows phone (38) - 8.0 关联启动: 使用外部程序打开一个文件或URI, 关联指定的文件类型或协议 作者:webabcd 介绍与众不同 windows ...

  3. SQL Server Insert时开启显式事务

    如果没法避免一条一条的写入,那么在处理前显示开启一个事务 begin tran  在处理完成后 commit 这样也要比不开显示事务会快很多! while i < 10000begin inse ...

  4. jQuery $.extend()用法总结

    Query开发插件的两个方法 1.jQuery.extend(object);为扩展jQuery类本身.为类添加新的方法. 2.jQuery.fn.extend(object);给jQuery对象添加 ...

  5. Sharepoint学习笔记—习题系列--70-573习题解析 -(Q91-Q93)

    Question 91You have a custom user profile property named MyProperty.You need to create a Web Part th ...

  6. android studio问题rendering problems no render target selected

    activity_main.xml选择Design显示rendering problems no render target selected 在stackOverflow上找到了答案: You ne ...

  7. iOS NSNumber转化NSString之description

    我们经常需要把一个数字转成字符串,当你不需要配合其他字符串的时候可以用description. /** description属于NSObject 值是NSNumber时候,不用stringWithF ...

  8. Android系统提供的开发常用的包名及作用

    android.app :提供高层的程序模型.提供基本的运行环境 android.content :包含各种的对设备上的数据进行访问和发布的类 android.database :通过内容提供者浏览和 ...

  9. [Android]编译错误:Could not get unknown property 'release' for SigningConfig container

    使用Gradle进行安卓编译时,出现如下错误: Could not get unknown property 'release' for SigningConfig container. 原因: 在主 ...

  10. IOS之UIImageView--小实例项目--带音效的拳皇动画

    内容大纲: 1.初步工作 2.开始敲代码 3.注意 4.可能遇到的错误 5.设置音频速率在代码顺序上的注意点 带音效的拳皇动画实例项目 初步工作 1.新建一Objective-C工程之后,将需要的拳皇 ...