类加载器详解

首先来了解一下字节码和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文件的时候要注意了。

转载：http://blog.csdn.net/jiangwei0910410003/article/details/17733153

原文地址：https://www.cnblogs.com/qiuyongqian/p/8515925.html

时间： 2024-09-30 16:41:04

类加载器详解的相关文章

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

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

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

本文转载自: http://blog.csdn.net/jiangwei0910410003/article/details/17733153 首先来了解一下字节码和class文件的区别: 我们知道,新建一个Java对象的时候,JVM要将这个对象对应的字节码加载到内存中,这个字节码的原始信息存放在classpath(就是我们新建Java工程的bin目录下)指定的目录下的.class文件,类加载需要将.class文件导入到硬盘中,经过一些处理之后变成字节码在加载到内存中. 下面来看一下简单的例子:

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

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

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

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

python--装饰器详解

Python---装饰器详解 定义: 本质上是一个函数.作用是用来装饰另一个函数(即被装饰函数),给被装饰函数添加功能.前提是不能改变被装饰函数的源代码和调用方式.这样的一个函数称之为装饰器. 解析: 下面我们话不多说,直接用代码说明.下面是一个函数. 1 def add(): 2 b=1+2 3 print(b45 add() 程序输出: -------- 3 -------- 现在我要给这个函数增加一个解释性的句子,如下,我们可以编写一个装饰器: 1 #原函数 2 def add(): 3

C编译器、链接器、加载器详解

摘自http://blog.csdn.net/zzxian/article/details/16820035 C编译器.链接器.加载器详解 一.概述 C语言的编译链接过程要把我们编写的一个c程序(源代码)转换成可以在硬件上运行的程序(可执行代码),需要进行编译和链接.编译就是把文本形式源代码翻译为机器语言形式的目标文件的过程.链接是把目标文件.操作系统的启动代码和用到的库文件进行组织形成最终生成可加载.可执行代码的过程. 过程图解如下: 预处理器:将.c 文件转化成 .i文件,使用的gcc命令是

SpringMVC拦截器详解[附带源码分析]

目录 前言 重要接口及类介绍 源码分析 拦截器的配置 编写自定义的拦截器 总结 前言 SpringMVC是目前主流的Web MVC框架之一. 如果有同学对它不熟悉,那么请参考它的入门blog:http://www.cnblogs.com/fangjian0423/p/springMVC-introduction.html 拦截器是每个Web框架必备的功能,也是个老生常谈的主题了. 本文将分析SpringMVC的拦截器功能是如何设计的,让读者了解该功能设计的原理. 重要接口及类介绍 1. Hand

spring--处理器拦截器详解——跟着开涛学SpringMVC

5.1.处理器拦截器简介 Spring Web MVC的处理器拦截器(如无特殊说明,下文所说的拦截器即处理器拦截器) 类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理.   5.1.1.常见应用场景 1.日志记录:记录请求信息的日志,以便进行信息监控.信息统计.计算PV(Page View)等. 2.权限检查:如登录检测,进入处理器检测检测是否登录,如果没有直接返回到登录页面: 3.性能监控:有时候系统在某段时间莫名其妙的慢,可以通过拦截器在进入处理器之前记录开始时

顶点着色器详解 (Vertex Shaders)

学习了顶点处理,你就知道固定功能流水线怎么将顶点从模型空间坐标系统转化到屏幕空间坐标系统.虽然固定功能流水线也可以通过设置渲染状态和参数来改变最终输出的结果,但是它的整体功能还是受限.当我们想实现一个外来的光照模型,外来的Fog或者点大小计算方式,等等,我们可能就放弃使用固定功能流水线,转而使用CPU来实现这些计算. 使用vertex shaders,它用一段小程序替换固定功能处理.这段小程序的输入是模型空间的顶点,输出齐次剪裁空间的顶点,并且还携带一些信息,如:per-vertex diffu