使用自己的ClassLoader实现热替换

首先实现一个自己的ClassLoader，该ClassLoader重写findClass方法。 从classpath中加载类资源。

注意，不要重写loadClass方法。  因为在使用自定义的MyClassLoader加载Person类的时候 。  Person类中需要依赖的其他对象， 都会默认使用MyClassLoader的loadClass方法进行加载。  如果重写了loadClass方法（像下面代码注释那样），就会导致jvm使用MyClassLoader来加载Object、String等等一些类。  当然，这些类在classpath是找不到的。 所以就会抛出ClassNotFoundException 。

1. package hot;
2. import java.io.ByteArrayOutputStream;
3. import java.io.File;
4. import java.io.FileInputStream;
5. import java.io.FileNotFoundException;
6. import java.io.IOException;
7. import java.nio.ByteBuffer;
8. import java.nio.channels.FileChannel;
9. public class MyClassLoader extends ClassLoader{
10. //  @Override
11. //  public Class<?> loadClass(String name) throws ClassNotFoundException {
12. //      return findClass(name);
13. //  }
14. @Override
15. protected Class<?> findClass(String name) throws ClassNotFoundException {
16. String classPath = MyClassLoader.class.getResource("/").getPath(); //得到classpath
17. String fileName = name.replace(".", "/") + ".class" ;
18. File classFile = new File(classPath , fileName);
19. if(!classFile.exists()){
20. throw new ClassNotFoundException(classFile.getPath() + " 不存在") ;
21. }
22. ByteArrayOutputStream bos = new ByteArrayOutputStream() ;
23. ByteBuffer bf = ByteBuffer.allocate(1024) ;
24. FileInputStream fis = null ;
25. FileChannel fc = null ;
26. try {
27. fis = new FileInputStream(classFile) ;
28. fc = fis.getChannel() ;
29. while(fc.read(bf) > 0){
30. bf.flip() ;
31. bos.write(bf.array(),0 , bf.limit()) ;
32. bf.clear() ;
33. }
34. } catch (FileNotFoundException e) {
35. e.printStackTrace();
36. } catch (IOException e) {
37. e.printStackTrace();
38. }finally{
39. try {
40. fis.close() ;
41. fc.close() ;
42. } catch (IOException e) {
43. e.printStackTrace();
44. }
45. }
46. return defineClass(bos.toByteArray() , 0 , bos.toByteArray().length) ;
47. }
48. }

现在来写一个Person类。  用与被MyClassLoader加载

1. package hot;
2. public class Person {
3. public void sayHello(){
4. System.out.println("hello world！");
5. }
6. }

然后写个测试类来测试。每隔1s就加载一下hot.Person类。

当StartUp测试类启动后， 我们可以手动修改personClass类， 并修改sayHello方法的内容。   将会看到热替换的效果。

注意， 测试类中在加载hot.Person的时候，使用的是myclassLoader的findClass方法。 而不是loadClass方法， 因为loadClass方法由于双亲委派模式，会将hot.Person交给myClassLoader的父ClassLoader进行加载。 而其父ClassLoader对加载的Class做了缓存，如果发现该类已经加载过， 就不会再加载第二次。  就算改类已经被改变

注意：同一个ClassLoader不能多次加载同一个类。 如果重复的加载同一个类 ， 将会抛出 loader (instance of  hot/MyClassLoader): attempted  duplicate class definition for name: "hot/Person" 异常。  所以，在替换Class的时候，  加载该Class的ClassLoader也必须用新的。

1. package hot;
2. import java.lang.reflect.InvocationTargetException;
3. import java.lang.reflect.Method;
4. public class StartUp {
5. public static void main(String[] args) throws ClassNotFoundException {
6. int i = 0 ;
7. while(true){
8. MyClassLoader mcl = new MyClassLoader() ;
9. System.out.println(mcl.getParent());
10. Class<?> personClass =  mcl.findClass("hot.Person");
11. try {
12. Object person =  personClass.newInstance() ;
13. Method sayHelloMethod = personClass.getMethod("sayHello") ;
14. sayHelloMethod.invoke(person) ;
15. System.out.println(++i);
16. } catch (InstantiationException e1) {
17. e1.printStackTrace();
18. } catch (IllegalAccessException e1) {
19. e1.printStackTrace();
20. } catch (SecurityException e) {
21. e.printStackTrace();
22. } catch (NoSuchMethodException e) {
23. e.printStackTrace();
24. } catch (IllegalArgumentException e) {
25. e.printStackTrace();
26. } catch (InvocationTargetException e) {
27. e.printStackTrace();
28. }
29. try {
30. Thread.sleep(1000) ;
31. } catch (InterruptedException e) {
32. e.printStackTrace();
33. }
34. }
35. }
36. }
37. 原文：http://blog.csdn.net/is_zhoufeng/article/details/26602689