使用本身的ClassLoader实现热替换

转载自：http://blog.csdn.net/is_zhoufeng/article/details/26602689

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

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

import java.io.ByteArrayOutputStream;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.IOException;  
import java.nio.ByteBuffer;  
import java.nio.channels.FileChannel;  
  
public class MyClassLoader extends ClassLoader{  
  
//  @Override  
//  public Class<?> loadClass(String name) throws ClassNotFoundException {  
//      return findClass(name);  
//  }  
      
    @Override  
    protected Class<?> findClass(String name) throws ClassNotFoundException {  
        String classPath = MyClassLoader.class.getResource("/").getPath(); //获得classpath  
        String fileName = name.replace(".", "/") + ".class" ;  
        File classFile = new File(classPath , fileName);  
        if(!classFile.exists()){  
            throw new ClassNotFoundException(classFile.getPath() + " 不存在") ;  
        }  
        ByteArrayOutputStream bos = new ByteArrayOutputStream() ;  
        ByteBuffer bf = ByteBuffer.allocate(1024) ;  
        FileInputStream fis = null ;  
        FileChannel fc = null ;  
        try {  
            fis = new FileInputStream(classFile) ;  
            fc = fis.getChannel() ;  
            while(fc.read(bf) > 0){  
                bf.flip() ;  
                bos.write(bf.array(),0 , bf.limit()) ;  
                bf.clear() ;  
            }  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }finally{  
            try {  
                fis.close() ;  
                fc.close() ;  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
        return defineClass(bos.toByteArray() , 0 , bos.toByteArray().length) ;  
    }  
  
  
  
  
}  

如今来写一个Person类。  用与被MyClassLoader加载

public class Person {  
      
    public void sayHello(){  
        System.out.println("hello world！");  
    }  
  
}  

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

import java.lang.reflect.InvocationTargetException;  
import java.lang.reflect.Method;  
  
public class StartUp {  
      
    public static void main(String[] args) throws ClassNotFoundException {  
          
        int i = 0 ;  
          
        while(true){  
            MyClassLoader mcl = new MyClassLoader() ;  
            System.out.println(mcl.getParent());  
            Class<?> personClass =  mcl.findClass("hot.Person");  
              
            try {  
                Object person =  personClass.newInstance() ;  
                Method sayHelloMethod = personClass.getMethod("sayHello") ;  
                sayHelloMethod.invoke(person) ;  
                System.out.println(++i);  
            } catch (InstantiationException e1) {  
                e1.printStackTrace();  
            } catch (IllegalAccessException e1) {  
                e1.printStackTrace();  
            } catch (SecurityException e) {  
                e.printStackTrace();  
            } catch (NoSuchMethodException e) {  
                e.printStackTrace();  
            } catch (IllegalArgumentException e) {  
                e.printStackTrace();  
            } catch (InvocationTargetException e) {  
                e.printStackTrace();  
            }  
              
            try {  
                Thread.sleep(1000) ;  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
          
    }  
  
}