JVM自定义classloader实现热替换

文章目录

通过自定义classloader和java的反射技术，可以自行控制类的加载。多数的Web容器，例如，Tomcat中就实现了自己的类加载器，在修改编译代码之后，可以在不停服务的情况下，运行新class文件中的代码；还有，OSGi中也实现了更加复杂的类加载器，被认为是控制类加载的经典代码。

本文试图用一个简单的可以控制类加载的示例，简单说明自定义类加载器的关键步骤。

假设我们有一个GetInfo类，为了简便起见，这个类只有一个static方法，

package problem1;
public class GetInfo
{
  public static void Output() {
    System.out.println("111111");
  }
}

另外一个程序不停循环调用该类的Output方法，并且，在Output方法发生变化之后，能够立刻调用到新的Output方法。本示例中，将简单的把print的内容替换为222222。简单的用伪代码表现这个思想可以是这样，

while(true){
  clz = loadClass("problem1.GetInfo");  // 需要使用自定义classloader
  clz.Output();                         // 需要使用反射技术
}

写成可以运行的java代码可以是这样，

package problem1;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.HashSet;
/*
 *  实现热替换，自定义ClassLoader，加载的是.class
 */
class HowswapCL extends ClassLoader {
	private String basedir; // 需要该类加载器直接加载的类文件的基目录
	private HashSet<String> dynaclazns; // 需要由该类加载器直接加载的类名
	public HowswapCL(String basedir, String[] clazns) {
		super(null); // 指定父类加载器为 null
		this.basedir = basedir;
		dynaclazns = new HashSet<String>();
		loadClassByMe(clazns);
	}
	private void loadClassByMe(String[] clazns) {
		for (int i = 0; i < clazns.length; i++) {
			loadDirectly(clazns[i]);
			dynaclazns.add(clazns[i]);
		}
	}
	private Class<?> loadDirectly(String name) {
		Class<?> cls = null;
		StringBuffer sb = new StringBuffer(basedir);
		String classname = name.replace('.', File.separatorChar) + ".class";
		sb.append(File.separator + classname);
		File classF = new File(sb.toString());
		try {
			cls = instantiateClass(name, new FileInputStream(classF),
					classF.length());
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return cls;
	}
	private Class<?> instantiateClass(String name, InputStream fin, long len) {
		byte[] raw = new byte[(int) len];
		try {
			fin.read(raw);
			fin.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return defineClass(name, raw, 0, raw.length);
	}
	protected Class<?> loadClass(String name, boolean resolve)
			throws ClassNotFoundException {
		Class<?> cls = null;
		cls = findLoadedClass(name);
		if (!this.dynaclazns.contains(name) && cls == null)
			cls = getSystemClassLoader().loadClass(name);
		if (cls == null)
			throw new ClassNotFoundException(name);
		if (resolve)
			resolveClass(cls);
		return cls;
	}
}
/*
 * 每隔2s运行一次，不断加载class
 */
class Multirun implements Runnable {
	public void run() {
		try {
			while (true) {
				// 每次都创建出一个新的类加载器
				// class需要放在自己package名字的文件夹下
				String url = System.getProperty("user.dir") + "/bin";// "/bin/problem1/GetInfo.class";
				HowswapCL cl = new HowswapCL(url,
						new String[] { "problem1.GetInfo" });
				Class<?> cls = cl.loadClass("problem1.GetInfo");
				Object foo = cls.newInstance();
				// 被调用函数的参数
				Method m = foo.getClass().getMethod("Output", new Class[] {});
				m.invoke(foo, new Object[] {});
				Thread.sleep(2000);
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}
}
public class Problem1 {
	public static void main(String[] args) {
		// 热替换测试代码
		Thread t;
		t = new Thread(new Multirun());
		t.start();
	}
}

这段代码就是上述伪代码的实现。HowswapCL类是自定义的classloader，它有2个成员，basedir和dynaclazns，分别表示需要加载的类的所在目录，和已经加载了的类名，同时实现了ClassLoader的接口loadClass。loadClass根据类名称去加载类实例，它先调用findLoadedClass查找这个类是否已经被加载了，如果没有被加载，并且dynaclazns里面也没有记录，那么就使用系统加载器加载（getSystemClassLoader().loadClass(name)）；如果dynaclazns里面有记录，但是还是没有被加载，那么就抛出ClassNotFound异常。

那dynaclazns中的内容是在何时添加的呢？是在初始化classloader的时候，也就是初始化HowswapCL类的时候，初始化过程中，先对每个basedir路径下需要加载的类文件调用loadDirectly做加载，然后将类名加入到dynaclazns中。在loadDirectly做加载的时候，先通过basedir路径和类名拼出class文件的路径，然后将class文件以二进制形式读入到对象raw中，最后根据类名和raw中二进制信息，调用defineClass加载这个类。

另外，loadClass的resolve参数在本例中没有用到，其含义是：resolve=true时，则保证已经装载，而且已经连接了。resolve=false时，则仅仅是去装载这个类，不关心是否连接了，所以此时可能被连接了，也可能没有被连接，默认是false。

运行起来的示例截图如下，

本文重点参考了这几篇文章¹，²，³。以上代码仅仅是测试代码，演示了自定义classloader实现热替换的基本原理，在设计上有诸多弊病。如果是实际项目的代码，一般会以接口的形式调用Output，而不会是静态方法；还有，每次调用都加载一次类，也的确很浪费性能，毕竟修改类的情况是少数，可以对指定路径下的类做一个监听，当发现class文件的修改时间或者是md5值发生改变的时候，就自动做一次重新加载，否则不做，这对性能有很好的提升，Eclipse的自动编译就是使用了类似这样的方法。

褚哥说|

我想写一些东西

JVM自定义classloader实现热替换