使用自己的ClassLoader实现热替换

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

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

 

 

[java]  view plain copy

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

 

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

 

[java]  view plain copy

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

 

然后写个测试类来测试。每隔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也必须用新的。 

 

[java]  view plain copy

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