类加载器
什么是类加载器和类加载器的作用
类加载器把硬盘上的字节码文件加载到内存中并做一些处理。
Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：
BootStrap
ExtClassLoader
AppClassLoader
类加载器本身也是Java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是java类，这正是BootStrap。BootStrap是嵌入在JVM内核里面的，JVM一启动，它就已经在那里了。BootStrap是用C++写的一段二进制代码。它可以加载其他类，这些其他类就包括其他的类加载器。
Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。
备注
1. 逐一编写如下代码来说明放置在不同位置的类确实由不同的类加载器加载的：
System.out.println(ClassLoaderTest.class.getClassLoader().getClass().getName());
//将上面语句的测试类改为System则抛NullPointerException，这两个类存放位置不同
System.out.println(System.class.getClassLoader().getClass().getName());
改为System.out.println(System.class.getClassLoader());打印的结果为null。
2.用下面的代码让查看类加载器的层次结构关系
ClassLoader loader = ClassLoaderTest.class.getClassLoader();
//打印出当前的类装载器，及该类装载器的各级父类装载器
while(loader != null)
{
System.out.println(loader.getClass().getName());
loader = loader.getParent();
}
代码
package classloader;
public class ClassLoaderTest {
public static void main(String[] args) {
/*
* 1. 取得ClassLoaderDemo类的字节码对象，
* 2. 再通过字节码对象取得它的类加载器对象，
* 3. 取得类加载器自己对应的字节码对象，
* 4. 取得类加载器自己对应的字节码对象的名字。
* 其实在第2步的时候就可以打印类加载器对象，结果为：
* sun.misc.Launcher$AppClassLoader@1d16e93
* 到第4步再打印的话得到的是类加载器精确的名字，结果为：
* sun.misc.Launcher$AppClassLoader
*/
System.out.println(
ClassLoaderTest.class
.getClassLoader()
.getClass()
.getName()
);
/*
* 再来看看System类的类加载器是什么。
*/
//System.out.println(
//System.class
//.getClassLoader()
//.getClass()
//.getName()
//);
/*
* 报错：java.lang.NullPointerException
* 空指针异常。我们可以一步一步往回退，最后确定getClassLoader()方法返回的就是null
* 或者，可以分析：如果一个对象存在，那么其字节码对象一定存在，则getClass方法不可能返回null，
* 则getName方法也就会有值。所以一定是这个对象不存在才会抛异常，而我们可以确定System.class对象一定存在
* 那就是getClassLoader方法返回null了。
*/
System.out.println(
System.class
.getClassLoader()
);
/*
* 结果确实为null。但这并不表示System类就没有类加载器。只是这个类加载器不是一个Java类，它就是BootStrap，
* BootStrap是嵌入到Java虚拟机里面的，是顶级的类加载器。
*/
/*
* 用下面的代码让查看类加载器的层次结构关系
*/
ClassLoader loader = ClassLoaderTest.class.getClassLoader();
//打印出当前的类装载器，及该类装载器的各级父类装载器
while(loader != null)
{
System.out.println(loader.getClass().getName());
loader = loader.getParent();
}
System.out.println(loader);
/*
* 结果为：
* sun.misc.Launcher$AppClassLoader
* sun.misc.Launcher$ExtClassLoader
* null
*/
}
}
类加载器之间的父子关系和管辖范围
备注
1. 查看ClassLoaderTest类的运行环境。
右击ClassLoaderTest -> Properties -> Run/Debug Settings 选中ClassLoaderTest(1) 点击Edit，点击JRE，可以看到Runtime JRE下面被选中的就是ClassLoaderTest类使用的运行环境。
2. 用eclipse的打包工具将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包。
右击ClassLoaderTest -> Export 选择Java下的 JAR file，点击next，在Select the export destination里面选择输出目录为ClassLoaderTest类的运行环境（例如为jdk1.6.0_03）下的jre/lib/ext目录。
注：jdk1.6.0_03/jre/lib/rt.jar放的是Java中定义的System, Vector, Date......等类。
而lib下的ext目录是放扩展jar包的。我们可以把的jar包放到ext里面，这样就可以被ExtClassLoader类加载器加载。
3. 再在eclipse中运行这个类，运行结果显示为ExtClassLoadr。
注意：此时的环境状态是classpath下有ClassLoaderTest.class，ext/itcast.jar包中也有ClassLoaderTest.class，而加载的时候是有ExtClassLoader加载的，即父子都有的时候，由父级来加载。而当父级中没有时，就由儿子来加载。这时候我们就需要了解类加载的具体过程和原理了。
类加载器的委托机制
当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？
1. 首先当前线程的类加载器去加载线程中的第一个类。
2. 如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。
3. 还可以直接调用指定的ClassLoader对象.loadClass()方法来指定某个类加载器去加载某个类。
每个类加载器加载类时，又先委托给其上级类加载器。
1. 当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException，而不是再去找发起者类加载器的儿子，因为没有getChild方法，即使有，那有多个儿子，找哪一个呢？
2. 对着类加载器的层次结构图和委托加载原理，解释先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后，运行结果为ExtClassLoader的原因。
备注
每个ClassLoader本身只能分别加载特定位置和目录中的类，但它们可以委托其他的类装载器去加载类，这就是类加载器的委托模式。类装载器一级级委托到BootStrap类加载器，当BootStrap无法加载当前所要加载的类时，然后才一级级回退到子孙类装载器去进行真正的加载。当回退到最初的类装载器时，如果它自己也不能完成类的装载，那就应报告ClassNotFoundException异常。
有一道面试，能不能自己写个类叫java.lang.System？
答：不能。为了不让我们写System类，类加载采用委托机制，这样可以保证爸爸们优先，也就是总是使用爸爸们能找到的类，这样总是使用java系统提供的System。
把先前编写的类加入到jdk的rt.jar中，会有怎样的效果呢？不行!!!看来是不能随意将自己的class文件加入进rt.jar文件中的。
编写自己的类加载器
知识讲解：
1. 自定义的类加载器的必须继承public abstract class ClassLoader
2. loadClass方法与findClass方法
loadClass方法内部会去找父级，当父级返回后，再接着调用findClass方法。我们自定义的类加载器只需要覆盖findClass方法，这样就保留了类加载的委托机制。如果覆盖loadClass方法，如果要保留类加载的委托机制，就得自己写代码实现如何去找父级，父级的父级，很麻烦，或者不写类加载的委托机制。所以最好是覆盖findClass方法，loadClass方法直接使用父类的就行。
使用findClass方法得到Class文件后，就要将Class文件转换成字节码，怎么做呢？由defineClass方法完成。
3. defineClass方法
编程步骤：
1. 编写一个对文件内容进行简单加密的程序。
2. 编写了一个自己的类装载器，可实现对加密过的类进行装载和解密。
3. 编写一个程序调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类。程序中可以除了使用ClassLoader.load方法之外，还可以使用设置线程的上下文类加载器或者系统类加载器，然后再使用Class.forName。
实验步骤：
1. 指定的一个class文件进行加密，加密结果存放到另外一个目录，例如： java MyClassLoader MyTest.class F:\itcast
2. 运行加载类的程序，结果能够被正常加载，但打印出来的类装载器名称为AppClassLoader：java MyClassLoader MyTest F:\itcast
3. 用加密后的类文件替换CLASSPATH环境下的类文件，再执行上一步操作就出问题了，错误说明是AppClassLoader类装载器装载失败。
4. 删除CLASSPATH环境下的类文件，再执行上一步操作就没问题了。
注：有包名的类不能调用无报名的类。
源码：
package classloader.myclassloader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* 自定义类加载器，同时有对类文件加密解密功能。
*/
public class MyClassLoader extends ClassLoader {
public static void main(String[] args) {
if (args.length < 2) {
System.err.println("需要两个参数：被加密文件的路径，加密后文件存放目录。");
return;
}
String srcPath = args[0];
String destDir = args[1];
String destFilename = new File(srcPath).getName();
String destPath = destDir + File.separator + destFilename;
InputStream is = null;
OutputStream os = null;
try {
is = new FileInputStream(srcPath);
os = new FileOutputStream(destPath);
cypher(is, os);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (os != null) {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 加密/解密。
*
* @param is
* 输入流
* @param os
* 输出流
* @throws IOException
*/
private static void cypher(InputStream is, OutputStream os)
throws IOException {
int b = -1;
while ((b = is.read()) != -1) {
os.write(b ^ 0xffff);
}
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
String classFilepath = classDir + File.separator + name + ".class";
FileInputStream fis = null;
ByteArrayOutputStream baos = null;
try {
System.out.println("MyClassLoader findClass..........");
fis = new FileInputStream(classFilepath);
baos = new ByteArrayOutputStream();
cypher(fis, baos);
byte[] bytes = baos.toByteArray();
// 加载字节码对象
return defineClass(bytes, 0, bytes.length);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// 关闭字节数组输入/输出流没有效果。关闭后仍然能读/写
//if (baos != null) {
//try {
//baos.close();
//} catch (IOException e) {
//e.printStackTrace();
//}
//}
}
// 没有找到，再到父类找
System.out.println("找父类的。。。。。。。。");
return super.findClass(name);
}
public MyClassLoader() {
}
private String classDir;
public MyClassLoader(String classDir) {
this.classDir = classDir;
}
}
package classloader.myclassloader;
import java.util.Date;
/**
* 被加密的类。 为什么要继承Date类呢？
* 因为被加密后，就不能创建指向此类的对象的引用。
* // 用自定义类加载器加载加密了的类
* Class clazz = new MyClassLoader("itcastlib").loadClass("ClassLoaderAttachment");
* // 编译都无法通过。因为ClassLoaderAttachment是被加密了的，类加载器AppClassLoader在
* // 加载MyClassLoaderTest的时候就无法解析ClassLoaderAttachment
* ClassLoaderAttachment cla = clazz.new Instatnce();
* // 但是我们可以通过ClassLoaderAttachment的父类来
*/
public class ClassLoaderAttachment extends Date {
@Override
public String toString() {
return "hello 你好！";
}
}
package classloader.myclassloader;
import java.util.Date;
/**
* 测试自定义类加载器的功能。
*/
public class MyClassLoaderTest {
public static void main(String[] args) {
/*
* 使用未加密的类文件时可以正常运行。
* 将生成的加密了的类文件替换掉原来的类文件（在workspace\工程名\bin\classloader\
* myclassloader目录下），再运行下面这一行代码就会报错： java.lang.ClassFormatError:
* Incompatible magic value 889275713 in class file
* classloader/myclassloader/ClassLoaderAttachment
* 因为被加密了，所以无法解析。只能由我们自己的类加载器去解析。
* 运行一次报错后，就无法通过编译了。
*/
//System.out.println(new ClassLoaderAttachment());
try {
// 使用自定义类加载器加载被加密了的类。
Class clazz = new MyClassLoader("itcastlib")
.loadClass("ClassLoaderAttachment");
/*
* 用加密了的ClassLoaderAttachment类文件替换掉原来的文件。
* 运行报错：Exception in thread "main" java.lang.ClassFormatError:
* Incompatible magic value 889275713 in class file
* classloader/myclassloader/ClassLoaderAttachment
* 运行一次报错后，就无法通过编译了。类加载器AppClassLoader在
* 加载MyClassLoaderTest的时候就无法解析ClassLoaderAttachment
* 怎么办呢？
*/
//ClassLoaderAttachment cla = (ClassLoaderAttachment) clazz.newInstance();
//System.out.println(cla);
/*
* 这就是让ClassLoaderAttachment继承Date的原因：
* 我们可以用Date对象引用来指向clazz创建出来的实例。而类加载器AppClassLoader
* 在加载本类（即MyClassLoaderTest）的时候可以解析Date
*/
Date d = (Date) clazz.newInstance();
System.out.println(d);
} catch (Exception e) {
e.printStackTrace();
}
}
}
一个类加载器的高级问题分析
情景一
编写一个能打印出自己的类加载器名称和当前类加载器的父子结构关系链的MyServlet，
正常发布后，看到打印结果为：
org.apache.catalina.loader.WebappClassLoader
java.net.URLClassLoader
sun.misc.Launcher$AppClassLoader
sun.misc.Launcher$ExtClassLoader
问题（情景二）
把MyServlet.class文件打jar包，放到ext目录（注：必须是tomcat用到的JRE环境下的lib/ext目录）中，重启tomcat，发现找不到HttpServlet的错误：java.lang.NoClassDefFoundError: javax/servlet/http/HttpServlet
分析MyServlet.clas本来是由WebappClassLoader来加载的，打成jar包放到ext目录下后，运行时，由于类加载的委托机制，WebappClassLoader会先委托其上级类加载器去加载MyServlet类，ExtClassLoader可以加载MyServlet，上级加载到了，WebappClassLoader就不会再去加载了。接着，由于MyServlet继承了HttpServlet，得加载HttpServlet。由类加载的委托机制，如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。因此ExtClassLoader去加载HttpServlet，但HttpServlet不在ext目录下（ExtClassLoader负责加载ext目录下的jar文件），所以就报错：找不到HttpServlet。注意：ExtClassLoader找不到类时，不会让其子类加载器再去找。
解决方法
把servlet.jar（HttpServlet类位于次jar包中）也放到ext目录中，问题解决了，打印的结果是：sun.misc.Launcher$ExtClassLoader
父级类加载器加载的类无法引用只能被子级类加载器加载的类，原理如下图：
由类加载的委托机制规则: 如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。
而MyServlet继承了HttpServlet,所以HttpServlet是由加载MyServlet的类加载器来加载。情景一由WebappClassLoader负责加载，情景二由ExtClassLoader负责加载。
源码
package cn.itcast.itcastweb.web.servlets;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 1. 部署到tomcat后访问本Servlet，观察输出结果，会看到有多个ClassLoader；
* 2. 将本类以jar包形式导出到tomcat使用的JDK下/jre/lib/ext/目录下。
* 重新启动tomcat，访问本Servlet，会看到报错信息：找不到类HttpServlet。
* 3. 将tomcat下/lib/servlet-api.jar拷贝到ext（步骤2中说明的）下，再启动tomcat访问本Servlet
* 观察输出结果，会看到只有一个ClassLoader了：sun.misc.Launcher$ExtClassLoader
*/
@WebServlet("/MyServlet")
public class MyServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
PrintWriter out = response.getWriter();
ClassLoader loader = this.getClass().getClassLoader();
// 循环输出类加载器，从子到父
while (loader != null) {
out.println(loader.getClass().getName() + "<br />");
loader = loader.getParent();
}
}
}
---------------------- ASP.Net+Unity开发、 .Net培训、期待与您交流！ ----------------------
9200
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
