[转载] Java高新技术第一篇：类加载器详解

本文转载自: http://blog.csdn.net/jiangwei0910410003/article/details/17733153

首先来了解一下字节码和class文件的区别：

我们知道，新建一个Java对象的时候，JVM要将这个对象对应的字节码加载到内存中，这个字节码的原始信息存放在classpath(就是我们新建Java工程的bin目录下)指定的目录下的.class文件,类加载需要将.class文件导入到硬盘中，经过一些处理之后变成字节码在加载到内存中。

下面来看一下简单的例子：

[java] view plain copy

  1. package com.loadclass.demo;
  2. import java.util.Date;
  3. import java.util.List;
  4. /**
  5. * 测试类
  6. * @author Administrator
  7. */
  8. public class ClassLoaderTest {
  9. @SuppressWarnings("rawtypes")
  10. public static void main(String[] args){
  11. //输出ClassLoaderText的类加载器名称
  12. System.out.println("ClassLoaderText类的加载器的名称:"+ClassLoaderTest.class.getClassLoader().getClass().getName());
  13. System.out.println("System类的加载器的名称:"+System.class.getClassLoader());
  14. System.out.println("List类的加载器的名称:"+List.class.getClassLoader());
  15. ClassLoader cl = ClassLoaderTest.class.getClassLoader();
  16. while(cl != null){
  17. System.out.print(cl.getClass().getName()+"->");
  18. cl = cl.getParent();
  19. }
  20. System.out.println(cl);
  21. }
  22. }

输出结果：

可以看到，ClassLoaderTest类时由AppClassLoader类加载器加载的。下面就来了解一下JVM中的各个类加载器，同时来解释一下运行的结果。

Java虚拟机中类加载器：

Java虚拟机中可以安装多个类加载器，系统默认三个主要的类加载器，每个类负责加载特定位置的类：

BootStrap,ExtClassLoader,AppClassLoader

类加载器也是Java类，因为Java类的类加载器本身也是要被类加载器加载的，显然必须有第一个类加载器不是Java类，这个正是BootStrap,使用C/C++代码写的，已经封装到JVM内核中了，而ExtClassLoader和AppClassLoader是Java类。

看一下类加载器的属性结构图：

Java虚拟机中的所有类加载器采用具有父子关系的树形结构进行组织，在实例化每个类加载器对象的时候，需要为其指定一个父级类加载器对象或者默认采用系统类加载器为其父级类加载

类加载器的委托机制：

当Java虚拟机要加载第一个类的时候，到底派出哪个类加载器去加载呢？

(1). 首先当前线程的类加载器去加载线程中的第一个类(当前线程的类加载器：Thread类中有一个get/setContextClassLoader(ClassLoader cl);方法，可以获取/指定本线程中的类加载器)

(2). 如果类A中引用了类B,Java虚拟机将使用加载类A的类加载器来加载类B

(3). 还可以直接调用ClassLoader.loadClass(String className)方法来指定某个类加载器去加载某个类

每个类加载器加载类时，又先委托给其上级类加载器当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则会抛出ClassNotFoundException,不是再去找发起者类加载器的儿子，因为没有getChild()方法。例如：如上图所示： MyClassLoader->AppClassLoader->Ext->ClassLoader->BootStrap.自定定义的MyClassLoader1首先会先委托给AppClassLoader,AppClassLoader会委托给ExtClassLoader,ExtClassLoader会委托给BootStrap，这时候BootStrap就去加载，如果加载成功，就结束了。如果加载失败，就交给ExtClassLoader去加载，如果ExtClassLoader加载成功了，就结束了，如果加载失败就交给AppClassLoader加载，如果加载成功，就结束了，如果加载失败，就交给自定义的MyClassLoader1类加载器加载，如果加载失败，就报ClassNotFoundException异常，结束。

对着类加载器的层次结构图和委托加载原理，解释先前的运行的结果

因为System类，List，Map等这样的系统提供jar类都在rt.jar中，所以由BootStrap类加载器加载，因为BootStrap是祖先类，不是Java编写的，所以打印出class为null

对于ClassLoaderTest类的加载过程，打印结果也是很清楚的。

现在再来做个试验来验证上面的结论：

首先将ClassLoaderTest.java打包成.jar文件(这个步骤就不说了吧,很简单的)

然后将.jar文件拷贝到Java的安装目录中的Java/jre7/lib/ext/目录下

这时候你在运行ClassLoaderTest类，结果如下：

这时候就发现了ClassLoaderTest的类加载器变成了ExtClassLoader,这时候就说明了上面的结论是正确的，因为ExtClassLoader加载jre/ext/*.jar，首先AppClassLoader类加载器发请求给ExtClassLoader,然后ExtClassLoader发请求给BootStrap，但是BootStrap没有找到ClassLoaderTest类，所以交给ExtClassLoader处理，这时候ExtClassLoader在my_lib.jar中找到了ClassLoaderTest类，所以就把它加载了，然后结束了。

其实采用这种树形的类加载机制的好处就在于：

能够很好的统一管理类加载，首先交给上级，如果上级有了，就加载，这样如果之前已经加载过的类，这时候在来加载它的时候只要拿过来用就可以了，无需二次加载了

下面来看一下怎么定义我们自己的一个类加载器MyClassLoader:

自己可以定义类加载器，要将自己定义的类加载器挂载到系统类加载器树上，在ClassLoader的构造方法中可以指定parent,没有指定的话，就使用默认的parent

这里看一下默认的parent是使用getSystemClassLoader方法获取的，这个方法的源码没有找到，所以只能通过代码来测试一下了

[java] view plain copy

  1. System.out.println("默认的类加载器:"+ClassLoaderTest.class.getClassLoader().getSystemClassLoader());

输入结果为：

所以默认的都是将自定义的类加载器挂载到系统类加载器的最低端AppClassLoader，这个也是很合理的。

自定义的类加载器必须继承抽象类ClassLoader然后重写findClass方法，其实他内部还有一个loadClass方法和defineClass方法，这两个方法的作用是：

loadClass方法的源代码：

[java] view plain copy

  1. public Class<?> loadClass(String name) throws ClassNotFoundException {
  2. return loadClass(name, false);
  3. }

再来看一下loadClass(name,false)方法的源代码：

[java] view plain copy

  1. protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException{
  2. //加上锁，同步处理，因为可能是多线程在加载类
  3. synchronized (getClassLoadingLock(name)) {
  4. //检查，是否该类已经加载过了，如果加载过了，就不加载了
  5. Class c = findLoadedClass(name);
  6. if (c == null) {
  7. long t0 = System.nanoTime();
  8. try {
  9. //如果自定义的类加载器的parent不为null,就调用parent的loadClass进行加载类
  10. if (parent != null) {
  11. c = parent.loadClass(name, false);
  12. } else {
  13. //如果自定义的类加载器的parent为null，就调用findBootstrapClass方法查找类，就是Bootstrap类加载器
  14. c = findBootstrapClassOrNull(name);
  15. }
  16. } catch (ClassNotFoundException e) {
  17. // ClassNotFoundException thrown if class not found
  18. // from the non-null parent class loader
  19. }
  20. if (c == null) {
  21. // If still not found, then invoke findClass in order
  22. // to find the class.
  23. long t1 = System.nanoTime();
  24. //如果parent加载类失败，就调用自己的findClass方法进行类加载
  25. c = findClass(name);
  26. // this is the defining class loader; record the stats
  27. sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
  28. sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
  29. sun.misc.PerfCounter.getFindClasses().increment();
  30. }
  31. }
  32. if (resolve) {
  33. resolveClass(c);
  34. }
  35. return c;
  36. }
  37. }

在loadClass代码中也可以看到类加载机制的原理，这里还有这个方法findBootstrapClassOrNull,看一下源代码：

[java] view plain copy

  1. private Class findBootstrapClassOrNull(String name)
  2. {
  3. if (!checkName(name)) return null;
  4. return findBootstrapClass(name);
  5. }

就是检查一下name是否是否正确，然后调用findBootstrapClass方法，但是findBootstrapClass方法是个native本地方法，看不到源代码了，但是可以猜测是用Bootstrap类加载器进行加载类的，这个方法我们也不能重写，因为如果重写了这个方法的话，就会破坏这种委托机制，我们还要自己写一个委托机制，很是蛋疼的。

defineClass这个方法很简单就是将class文件的字节数组编程一个class对象，这个方法肯定不能重写，内部实现是在C/C++代码中实现的

findClass这个方法就是根据name来查找到class文件，在loadClass方法中用到，所以我们只能重写这个方法了，只要在这个方法中找到class文件，再将它用defineClass方法返回一个Class对象即可。

这三个方法的执行流程是：每个类加载器：loadClass->findClass->defineClass

 

前期的知识了解后现在就来实现了

首先来看一下需要加载的一个类:ClassLoaderAttachment.java:

[java] view plain copy

  1. package com.loadclass.demo;
  2. import java.util.Date;
  3. /**
  4. * 加载类
  5. * @author Administrator
  6. */
  7. public class ClassLoaderAttachment extends Date{
  8. private static final long serialVersionUID = 8627644427315706176L;
  9. //打印数据
  10. @Override
  11. public String toString(){
  12. return "Hello ClassLoader!";
  13. }
  14. }

这个类中输出一段话即可：编译成ClassLoaderAttachment.class

再来看一下自定义的MyClassLoader.java:

[java] view plain copy

  1. package com.loadclass.demo;
  2. import java.io.ByteArrayOutputStream;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.InputStream;
  6. import java.io.OutputStream;
  7. /**
  8. * 自定义的类加载器
  9. * @author Administrator
  10. */
  11. public class MyClassLoader extends ClassLoader{
  12. //需要加载类.class文件的目录
  13. private String classDir;
  14. //无参的构造方法，用于class.newInstance()构造对象使用
  15. public MyClassLoader(){
  16. }
  17. public MyClassLoader(String classDir){
  18. this.classDir = classDir;
  19. }
  20. @SuppressWarnings("deprecation")
  21. @Override
  22. protected Class<?> findClass(String name) throws ClassNotFoundException {
  23. //class文件的路径
  24. String classPathFile = classDir + "/" + name + ".class";
  25. try {
  26. //将class文件进行解密
  27. FileInputStream fis = new FileInputStream(classPathFile);
  28. ByteArrayOutputStream bos = new ByteArrayOutputStream();
  29. encodeAndDecode(fis,bos);
  30. byte[] classByte = bos.toByteArray();
  31. //将字节流变成一个class
  32. return defineClass(classByte,0,classByte.length);
  33. } catch (Exception e) {
  34. e.printStackTrace();
  35. }
  36. return super.findClass(name);
  37. }
  38. //测试，先将ClassLoaderAttachment.class文件加密写到工程的class_temp目录下
  39. public static void main(String[] args) throws Exception{
  40. //配置运行参数
  41. String srcPath = args[0];//ClassLoaderAttachment.class原路径
  42. String desPath = args[1];//ClassLoaderAttachment.class输出的路径
  43. String desFileName = srcPath.substring(srcPath.lastIndexOf("\\")+1);
  44. String desPathFile = desPath + "/" + desFileName;
  45. FileInputStream fis = new FileInputStream(srcPath);
  46. FileOutputStream fos = new FileOutputStream(desPathFile);
  47. //将class进行加密
  48. encodeAndDecode(fis,fos);
  49. fis.close();
  50. fos.close();
  51. }
  52. /**
  53. * 加密和解密算法
  54. * @param is
  55. * @param os
  56. * @throws Exception
  57. */
  58. private static void encodeAndDecode(InputStream is,OutputStream os) throws Exception{
  59. int bytes = -1;
  60. while((bytes = is.read())!= -1){
  61. bytes = bytes ^ 0xff;//和0xff进行异或处理
  62. os.write(bytes);
  63. }
  64. }
  65. }

这个类中定义了一个加密和解密的算法，很简单的，就是将字节和oxff异或一下即可，而且这个算法是加密和解密的都可以用，很是神奇呀！

当然我们还要先做一个操作就是，将ClassLoaderAttachment.class加密后的文件存起来，也就是在main方法中执行的，这里我是在项目中新建一个class_temp文件夹用来皴法加密后的class文件：

同时采用的是参数的形式来进行赋值的，所以在运行的MyClassLoader的时候要进行输入参数的配置：右击MyClassLoader->run as -> run configurations

第一个参数是ClassLoaderAttachment.class文件的源路径，第二个参数是加密后存放的目录，运行MyClassLoader之后，刷新class_temp文件夹，出现了ClassLoaderAttachment.class，这个是加密后的class文件。

下面来看一下测试类：

[java] view plain copy

  1. package com.loadclass.demo;
  2. import java.util.Date;
  3. import java.util.List;
  4. /**
  5. * 测试类
  6. * @author Administrator
  7. */
  8. public class ClassLoaderTest {
  9. @SuppressWarnings("rawtypes")
  10. public static void main(String[] args){
  11. //输出ClassLoaderText的类加载器名称
  12. System.out.println("ClassLoaderText类的加载器的名称:"+ClassLoaderTest.class.getClassLoader().getClass().getName());
  13. System.out.println("System类的加载器的名称:"+System.class.getClassLoader());
  14. System.out.println("List类的加载器的名称:"+List.class.getClassLoader());
  15. System.out.println("默认的类加载器:"+ClassLoaderTest.class.getClassLoader().getSystemClassLoader());
  16. ClassLoader cl = ClassLoaderTest.class.getClassLoader();
  17. while(cl != null){
  18. System.out.print(cl.getClass().getName()+"->");
  19. cl = cl.getParent();
  20. }
  21. System.out.println(cl);
  22. try {
  23. Class classDate = new MyClassLoader("class_temp").loadClass("ClassLoaderAttachment");
  24. Date date = (Date) classDate.newInstance();
  25. //输出ClassLoaderAttachment类的加载器名称
  26. System.out.println("ClassLoader:"+date.getClass().getClassLoader().getClass().getName());
  27. System.out.println(date);
  28. } catch (Exception e1) {
  29. e1.printStackTrace();
  30. }
  31. }
  32. }

运行ClassLoaderTest类，运行结果如下：

ClassLoaderAttachment类的加载器是我们自己定义的类加载器MyClassLoader，同时也输出了Hello ClassLoader字段

到此不要以为结束了，这里还有很多的问题呀，看一下问题的结果是没有问题，但是这里面还有很多的东西需要去理解的，首先来看一下，按照我们之前说的类加载机制，应该是先交给父级的类加载器，AppClassLoader->ExtClassLoader->BootStrap，ExtClassLoader和BootStrap没有找到ClassLoaderAttach.class，但是AppClassLoader类加载器应该能找到呀，可以为什么也没有找到呢？这时因为loadClass方法在使用系统类加载器的时候需要传递全称(包括包名)，我们传递ClassLoaderAttachment的话，AppClassLoader也是没有找到这个ClassLoaderAttachment,所以还是MyClassLoader处理了，不信的话可以试一下：

现在将

[java] view plain copy

  1. Class classDate = new MyClassLoader("class_temp").loadClass("ClassLoaderAttachment");

改成：

[java] view plain copy

  1. Class classDate = new MyClassLoader("class_temp").loadClass("com.loadclass.demo.ClassLoaderAttachment");

结果运行：

这时候的加载器是AppClassLoader了，所以要注意loadClass方法传递的参数

到这里我们貌似还没有测试到我们加密后的class文件，我们现在将工程目录中的ClassLoaderAttachment.class删除，将class_temp中加密的ClassLoaderAttachment.class拷贝过去，然后再运行：

这时候就会报错了，不合适的魔数错误(class文件的前六个字节是个魔数用来标识class文件的)，这时候就对了，因为ClassLoaderAttachment.class使我们加密后的class文件,AppClassLoader是不认识的，所以报这个错误了，只有用我们自己定义的类加载器来进行解密才可以正确的访问的。到这里总算是说完了，搞了一上午，头都写大了，很是麻烦呀！

注意的两个问题：

1.可能在测试的过程中有这样的情况就是ClassLoaderTest类并没有执行，这个是因为在第一个测试的时候，将ClassLoaderTest类打成.jar放到jre目录中了，所以你后续修改ClassLoaderTest类的话，运行没有效果，因为它加载的类还是jre中的jar中的ClassLoaderTest类，所以你应该将jre中的jar删除即可。

2.就是ClassLoaderAttachment只要保存就会编译成.class文件，所以你在拷贝ClassLoaderAttachment.class文件的时候要注意了。

时间： 2024-11-06 23:35:39

[转载] Java高新技术第一篇：类加载器详解的相关文章

入木三分学网络第一篇--VRRP协议详解第一篇（转）

因为keepalived使用了VRRP协议,所有有必要熟悉一下. 虚拟路由冗余协议(Virtual Router Redundancy Protocol,简称VRRP)是解决局域网中配置静态网关时,静态网关出现单点失效现象的路由协议. VRRP广泛应用在边缘网络中,它的设计目标是支持特定情况下IP数据流量失败转移不会引起混乱,允许主机使用单路由器(位于一个虚拟路由器组中, 在该组中,只有一台路由器--master路由器工作,转发数据包,其它路由器是backup路由器,不参与转发数据包),以及在实

Java高新技术第一篇：类加载器详解

首先来了解一下字节码和class文件的区别: 我们知道,新建一个Java对象的时候,JVM要将这个对象对应的字节码加载到内存中,这个字节码的原始信息存放在classpath(就是我们新建Java工程的bin目录下)指定的目录下的.class文件,类加载需要将.class文件导入到硬盘中,经过一些处理之后变成字节码在加载到内存中. 下面来看一下简单的例子: [java] view plain copy package com.loadclass.demo; import java.util.Dat

类加载器详解

首先来了解一下字节码和class文件的区别: 我们知道,新建一个java对象的时候,JVM要将这个对象对应的字节码加载到内存中,这个字节码的原始信息存放在classpath(就是我们新建Java工程的bin目录下)指定的目录下的.class文件,类加载需要将.class文件导入到硬盘中,经过一些处理之后变成字节码在加载到内存中. 下面来看一下简单的例子: [java] view plain copy package com.loadclass.demo; import java.util.Dat

Java---JUnita、注解与类加载器详解以及实例

JUnit软件测试技术(工具) 在项目中建立专门用户测试的包结构. 在Junit中,通过@Test注解,可以运行一个方法. ★ Junit注解说明 使用了@Test注解应该满足以下条件: 1) 必须是无参数的非静态方法. 2) 添加@Test注解的类,必须拥有一个无参数的公开构造 ★ JUnit测试示例演示 1.运行完成后,可以在Junit的窗口上看到运行所用的时间和结果信息. 2.被测试程序的运行结果出现在控制台(Console)上. "项目"代码: package cn.hncu.

[转载]Java中hashCode与equal方法详解

转载自http://blog.csdn.net/jiangwei0910410003/article/details/22739953 Java中的equals方法和hashCode方法是Object中的,所以每个对象都是有这两个方法的,有时候我们需要实现特定需求,可能要重写这两个方法,今天就来介绍一些这两个方法的作用. equals()和hashCode()方法是用来在同一类中做比较用的,尤其是在容器里如set存放同一类对象时用来判断放入的对象是否重复. 这里我们首先要明白一个问题: equa

「C语言回顾之旅」第一篇：指针详解

说明: 最近学校课程开设了<数据结构>的课程,无疑,数据结构的重要性在IT生涯的进阶路上是不可置疑的,也常说,数据结构是专业性与非专业性的分界线.所以无论以后走的是什么方向,毕竟是读计算机专业的,所以必须学好数据结构的.虽然目前我给自己定的方向是走运维/系统架构方向的,可有句话说得好,不懂开发的运维注定会被淘汰,在IT这一行,要让自己变得更加强大.最近也一直在学Python,感觉还不错,学数据结构相信对自己也肯定有好处的,对一些较为底层的知识有些了解和理解,这样才能走得更远! 无疑C语言就很重

[转载]java之yield(),sleep(),wait()区别详解

原文地址:http://dylanxu.iteye.com/blog/1322066 1.sleep() 使当前线程(即调用该方法的线程)暂停执行一段时间,让其他线程有机会继续执行,但它并不释放对象锁. 也就是说如果有synchronized同步快,其他线程仍然不能访问共享数据.注意该方法要捕捉异常. 例 如有两个线程同时执行(没有synchronized)一个线程优先级为MAX_PRIORITY,另一个为MIN_PRIORITY, 如果没有 Sleep()方法,只有高优先级的线程执行完毕后,低

web运维第一篇:nginx配置文件详解笔记

#定义Nginx运行的用户和用户组 user www www; #nginx进程数,建议设置为等于CPU总核心数. worker_processes 8; #全局错误日志定义类型,[ debug | info | notice | warn | error | crit ] error_log /var/log/nginx/error.log info; #进程文件 pid /var/run/nginx.pid; #一个nginx进程打开的最多文件描述符数目,理论值应该是最多打开文件数(系统的值

JVM类加载机制详解（二）类加载器与双亲委派模型

在上一篇JVM类加载机制详解(一)JVM类加载过程中说到,类加载机制的第一个阶段加载做的工作有: 1.通过一个类的全限定名(包名与类名)来获取定义此类的二进制字节流(Class文件).而获取的方式,可以通过jar包.war包.网络中获取.JSP文件生成等方式. 2.将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构.这里只是转化了数据结构,并未合并数据.(方法区就是用来存放已被加载的类信息,常量,静态变量,编译后的代码的运行时内存区域) 3.在内存中生成一个代表这个类的java.lan