JVM自定义类加载器加载指定classPath下的所有class及jar
一、jvm中的类加载器类型
从java虚拟机的角度讲，只有两种不同的类加载器：启动类加载器和其他类加载器。
1.启动类加载器(boostrap classloader)：这个是由c++实现的，主要负责java_home/lib目录下的核心 api 或 -xbootclasspath 选项指定的jar包装入工作。
2.其他类加载器：由java实现，可以在方法区找到其class对象。这里又细分为几个加载器
a).扩展类加载器（extension classloader）：负责用于加载java_home/lib/ext目录中的，或者被-djava.ext.dirs系统变量指定所指定的路径中所有类库(jar)，开发者可以直接使用扩展类加载器。java.ext.dirs系统变量所指定的路径的可以通过system.getproperty("java.ext.dirs")来查看。
b).应用程序类加载器（application classloader）：负责java -classpath或-djava.class.path所指的目录下的类与jar包装入工作。开发者可以直接使用这个类加载器。在没有指定自定义类加载器的情况下，这就是程序的默认加载器。
c).自定义类加载器（user classloader）：在程序运行期间, 通过java.lang.classloader的子类动态加载class文件, 体现java动态实时类装入特性。
这四个类加载器的层级关系，如下图所示。
二、为什么要自定义类加载器
- 区分同名的类：假定在tomcat 应用服务器，上面部署着许多独立的应用，同时他们拥有许多同名却不同版本的类。要区分不同版本的类当然是需要每个应用都拥有自己独立的类加载器了，否则无法区分使用的具体是哪一个。
- 类库共享：每个web应用在tomcat中都可以使用自己版本的jar。但存在如servlet-api.jar，java原生的包和自定义添加的java类库可以相互共享。
- 加强类：类加载器可以在 loadclass 时对 class 进行重写和覆盖，在此期间就可以对类进行功能性的增强。比如使用javassist对class进行功能添加和修改，或者添加面向切面编程时用到的动态代理，以及 debug 等原理。
- 热替换：在应用正在运行的时候升级软件，不需要重新启动应用。比如toccat服务器中jsp更新替换。
三、自定义类加载器
3.1 classloader实现自定义类加载器相关方法说明
要实现自定义类加载器需要先继承classloader，classloader类是一个抽象类，负责加载classes的对象。自定义classloader中至少需要了解其中的三个的方法： loadclass,findclass,defineclass。
public class<?> loadclass(string name) throws classnotfoundexception {
return loadclass(name, false);
protected class<?> findclass(string name) throws classnotfoundexception {
throw new classnotfoundexception(name);
}
protected final class<?> defineclass(string name, byte[] b, int off, int len)
throws classformaterror
{
return defineclass(name, b, off, len, null);
}
loadclass：jvm在加载类的时候，都是通过classloader的loadclass()方法来加载class的，loadclass使用双亲委派模式。如果要改变双亲委派模式，可以修改loadclass来改变class的加载方式。双亲委派模式这里就不赘述了。
findclass：classloader通过findclass()方法来加载类。自定义类加载器实现这个方法来加载需要的类，比如指定路径下的文件，字节流等。
definedclass：definedclass在findclass中使用，通过调用传进去一个class文件的字节数组，就可以方法区生成一个class对象，也就是findclass实现了类加载的功能了。
贴上一段classloader中loadclass源码，见见真面目...
protected class<?> loadclass(string name, boolean resolve)
throws classnotfoundexception
{
synchronized (getclassloadinglock(name)) {
// first, check if the class has already been loaded
class<?> c = findloadedclass(name);
if (c == null) {
long t0 = system.nanotime();
try {
if (parent != null) {
c = parent.loadclass(name, false);
} else {
c = findbootstrapclassornull(name);
}
} catch (classnotfoundexception e) {
// classnotfoundexception thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// if still not found, then invoke findclass in order
// to find the class.
long t1 = system.nanotime();
c = findclass(name);
// this is the defining class loader; record the stats
sun.misc.perfcounter.getparentdelegationtime().addtime(t1 - t0);
sun.misc.perfcounter.getfindclasstime().addelapsedtimefrom(t1);
sun.misc.perfcounter.getfindclasses().increment();
}
}
if (resolve) {
resolveclass(c);
}
return c;
}
}
源码说明...
/**
* loads the class with the specified <a href="#name">binary name</a>. the
* default implementation of this method searches for classes in the
* following order:
*
* <ol>
*
* <li><p> invoke {@link #findloadedclass(string)} to check if the class
* has already been loaded. </p></li>
*
* <li><p> invoke the {@link #loadclass(string) <tt>loadclass</tt>} method
* on the parent class loader. if the parent is <tt>null</tt> the class
* loader built-in to the virtual machine is used, instead. </p></li>
*
* <li><p> invoke the {@link #findclass(string)} method to find the
* class. </p></li>
*
* </ol>
*
* <p> if the class was found using the above steps, and the
* <tt>resolve</tt> flag is true, this method will then invoke the {@link
* #resolveclass(class)} method on the resulting <tt>class</tt> object.
*
* <p> subclasses of <tt>classloader</tt> are encouraged to override {@link
* #findclass(string)}, rather than this method. </p>
*
* <p> unless overridden, this method synchronizes on the result of
* {@link #getclassloadinglock <tt>getclassloadinglock</tt>} method
* during the entire class loading process.
*
* @param name
* the <a href="#name">binary name</a> of the class
*
* @param resolve
* if <tt>true</tt> then resolve the class
*
* @return the resulting <tt>class</tt> object
*
* @throws classnotfoundexception
* if the class could not be found
*/
翻译过来大概是：使用指定的二进制名称来加载类，这个方法的默认实现按照以下顺序查找类： 调用findloadedclass(string)方法检查这个类是否被加载过 使用父加载器调用loadclass(string)方法，如果父加载器为null，类加载器装载虚拟机内置的加载器调用findclass(string)方法装载类， 如果，按照以上的步骤成功的找到对应的类，并且该方法接收的resolve参数的值为true,那么就调用resolveclass(class)方法来处理类。 classloader的子类最好覆盖findclass(string)而不是这个方法。 除非被重写，这个方法默认在整个装载过程中都是同步的（线程安全的）。
resolveclass：class载入必须链接（link），链接指的是把单一的class加入到有继承关系的类树中。这个方法给classloader用来链接一个类，如果这个类已经被链接过了，那么这个方法只做一个简单的返回。否则，这个类将被按照 java™规范中的execution描述进行链接。
3.2 自定义类加载器实现
按照3.1的说明，继承classloader后重写了findclass方法加载指定路径上的class。先贴上自定义类加载器。
package com.chenerzhu.learning.classloader;
import java.nio.file.files;
import java.nio.file.paths;
/**
* @author chenerzhu
* @create 2018-10-04 10:47
**/
public class myclassloader extends classloader {
private string path;
public myclassloader(string path) {
this.path = path;
}
@override
protected class<?> findclass(string name) throws classnotfoundexception {
try {
byte[] result = getclass(name);
if (result == null) {
throw new classnotfoundexception();
} else {
return defineclass(name, result, 0, result.length);
}
} catch (exception e) {
e.printstacktrace();
}
return null;
}
private byte[] getclass(string name) {
try {
return files.readallbytes(paths.get(path));
} catch (exception e) {
e.printstacktrace();
}
return null;
}
}
以上就是自定义的类加载器了，实现的功能是加载指定路径的class。再看看如何使用。
package com.chenerzhu.learning.classloader;
import org.junit.test;
/**
* created by chenerzhu on 2018/10/4.
*/
public class myclassloadertest {
@test
public void testclassloader() throws exception {
myclassloader myclassloader = new myclassloader("src/test/resources/bean/hello.class");
class clazz = myclassloader.loadclass("com.chenerzhu.learning.classloader.bean.hello");
object obj = clazz.newinstance();
system.out.println(obj);
system.out.println(obj.getclass().getclassloader());
}
}
首先通过构造方法创建myclassloader对象myclassloader，指定加载src/test/resources/bean/hello.class路径的hello.class（当然这里只是个例子，直接指定一个class的路径了）。然后通过myclassloader方法loadclass加载hello的class对象，最后实例化对象。以下是输出结果，看得出来实例化成功了，并且类加载器使用的是myclassloader。
com.chenerzhu.learning.classloader.bean.hello@2b2948e2 com.chenerzhu.learning.classloader.myclassloader@335eadca
四、类class卸载
jvm中class和meta信息存放在permgen space区域（jdk1.8之后存放在matespace中）。如果加载的class文件很多，那么可能导致元数据空间溢出。引起java.lang.outofmemory异常。对于有些class我们可能只需要使用一次，就不再需要了，也可能我们修改了class文件，我们需要重新加载 newclass，那么oldclass就不再需要了。所以需要在jvm中卸载（unload）类class。
jvm中的class只有满足以下三个条件，才能被gc回收，也就是该class被卸载（unload）：
- 该类所有的实例都已经被gc。
- 该类的java.lang.class对象没有在任何地方被引用。
- 加载该类的classloader实例已经被gc。
很容易理解，就是要被卸载的类的classloader实例已经被gc并且本身不存在任何相关的引用就可以被卸载了，也就是jvm清除了类在方法区内的二进制数据。
jvm自带的类加载器所加载的类，在虚拟机的生命周期中，会始终引用这些类加载器，而这些类加载器则会始终引用它们所加载的类的class对象。因此这些class对象始终是可触及的，不会被卸载。而用户自定义的类加载器加载的类是可以被卸载的。虽然满足以上三个条件class可以被卸载，但是gc的时机我们是不可控的，那么同样的我们对于class的卸载也是不可控的。
五、jvm自定义类加载器加载指定classpath下的所有class及jar
经过以上几个点的说明，现在可以实现jvm自定义类加载器加载指定classpath下的所有class及jar了。这里没有限制class和jar的位置，只要是classpath路径下的都会被加载进jvm，而一些web应用服务器加载是有限定的，比如tomcat加载的是每个应用classpath+“/classes”加载class，classpath+“/lib”加载jar。以下就是代码啦...
package com.chenerzhu.learning.classloader;
import java.io.bytearrayoutputstream;
import java.io.file;
import java.io.ioexception;
import java.io.inputstream;
import java.nio.file.files;
import java.nio.file.paths;
import java.util.enumeration;
import java.util.map;
import java.util.concurrent.concurrenthashmap;
import java.util.jar.jarentry;
import java.util.jar.jarfile;
/**
* @author chenerzhu
* @create 2018-10-04 12:24
**/
public class classpathclassloader extends classloader{
private static map<string, byte[]> classmap = new concurrenthashmap<>();
private string classpath;
public classpathclassloader() {
}
public classpathclassloader(string classpath) {
if (classpath.endswith(file.separator)) {
this.classpath = classpath;
} else {
this.classpath = classpath + file.separator;
}
prereadclassfile();
prereadjarfile();
}
public static boolean addclass(string classname, byte[] bytecode) {
if (!classmap.containskey(classname)) {
classmap.put(classname, bytecode);
return true;
}
return false;
}
/**
* 这里仅仅卸载了myclassloader的classmap中的class,虚拟机中的
* class的卸载是不可控的
* 自定义类的卸载需要myclassloader不存在引用等条件
* @param classname
* @return
*/
public static boolean unloadclass(string classname) {
if (classmap.containskey(classname)) {
classmap.remove(classname);
return true;
}
return false;
}
/**
* 遵守双亲委托规则
*/
@override
protected class<?> findclass(string name) {
try {
byte[] result = getclass(name);
if (result == null) {
throw new classnotfoundexception();
} else {
return defineclass(name, result, 0, result.length);
}
} catch (exception e) {
e.printstacktrace();
}
return null;
}
private byte[] getclass(string classname) {
if (classmap.containskey(classname)) {
return classmap.get(classname);
} else {
return null;
}
}
private void prereadclassfile() {
file[] files = new file(classpath).listfiles();
if (files != null) {
for (file file : files) {
scanclassfile(file);
}
}
}
private void scanclassfile(file file) {
if (file.exists()) {
if (file.isfile() && file.getname().endswith(".class")) {
try {
byte[] bytecode = files.readallbytes(paths.get(file.getabsolutepath()));
string classname = file.getabsolutepath().replace(classpath, "")
.replace(file.separator, ".")
.replace(".class", "");
addclass(classname, bytecode);
} catch (ioexception e) {
e.printstacktrace();
}
} else if (file.isdirectory()) {
for (file f : file.listfiles()) {
scanclassfile(f);
}
}
}
}
private void prereadjarfile() {
file[] files = new file(classpath).listfiles();
if (files != null) {
for (file file : files) {
scanjarfile(file);
}
}
}
private void readjar(jarfile jar) throws ioexception {
enumeration<jarentry> en = jar.entries();
while (en.hasmoreelements()) {
jarentry je = en.nextelement();
je.getname();
string name = je.getname();
if (name.endswith(".class")) {
//string classname = name.replace(file.separator, ".").replace(".class", "");
string classname = name.replace("\\", ".")
.replace("/", ".")
.replace(".class", "");
inputstream input = null;
bytearrayoutputstream baos = null;
try {
input = jar.getinputstream(je);
baos = new bytearrayoutputstream();
int buffersize = 1024;
byte[] buffer = new byte[buffersize];
int bytesnumread = 0;
while ((bytesnumread = input.read(buffer)) != -1) {
baos.write(buffer, 0, bytesnumread);
}
addclass(classname, baos.tobytearray());
} catch (exception e) {
e.printstacktrace();
} finally {
if (baos != null) {
baos.close();
}
if (input != null) {
input.close();
}
}
}
}
}
private void scanjarfile(file file) {
if (file.exists()) {
if (file.isfile() && file.getname().endswith(".jar")) {
try {
readjar(new jarfile(file));
} catch (ioexception e) {
e.printstacktrace();
}
} else if (file.isdirectory()) {
for (file f : file.listfiles()) {
scanjarfile(f);
}
}
}
}
public void addjar(string jarpath) throws ioexception {
file file = new file(jarpath);
if (file.exists()) {
jarfile jar = new jarfile(file);
readjar(jar);
}
}
}
如何使用的代码就不贴了，和3.2节自定义类加载器的使用方式一样。只是构造方法的参数变成classpath了，篇末有代码。当创建myclassloader对象时，会自动添加指定classpath下面的所有class和jar里面的class到classmap中，classmap维护classname和classcode字节码的关系，只是个缓冲作用，避免每次都从文件中读取。自定义类加载器每次loadclass都会首先在jvm中找是否已经加载classname的类，如果不存在就会到classmap中取，如果取不到就是加载错误了。
六、最后
至此，jvm自定义类加载器加载指定classpath下的所有class及jar已经完成了。这篇博文花了两天才写完，在写的过程中有意识地去了解了许多代码的细节，收获也很多。本来最近仅仅是想实现quartz控制台页面任务添加支持动态class，结果不知不觉跑到类加载器的坑了，在此也趁这个机会总结一遍。当然以上内容并不能保证正确，所以希望大家看到错误能够指出，帮助我更正已有的认知，共同进步。。。
本文的代码已经上传github： 欢迎下载和指正。
参考文章：