1  package testjvm.testclassloader;   2    3  import java.io.File;   4  import java.io.FileNotFoundException;   5  import java.net.MalformedURLException;   6  import java.net.URL;   7  import java.net.URLClassLoader;   8  import java.util.HashMap;   9  import java.util.Map;  10   11  /**

 12   * 只要功能是重新加载更改过的.class文件，达到热替换的作用

 13   *  @author  banana

 14    */  15  public  class HotSwapURLClassLoader  extends URLClassLoader {  16      // 缓存加载class文件的最后最新修改时间

 17       public  static Map<String,Long> cacheLastModifyTimeMap =  new HashMap<String,Long>();  18      // 工程class类所在的路径

 19       public  static String projectClassPath = "D:/Ecpworkspace/ZJob-Note/bin/";  20      // 所有的测试的类都在同一个包下

 21       public  static String packagePath = "testjvm/testclassloader/";  22       23      private  static HotSwapURLClassLoader hcl =  new HotSwapURLClassLoader();  24       25      public HotSwapURLClassLoader() {  26          // 设置ClassLoader加载的路径

 27           super(getMyURLs());  28     }  29       30      public  static HotSwapURLClassLoader  getClassLoader(){  31          return hcl;  32     }   33   34      private  static  URL[] getMyURLs(){  35         URL url =  null;  36          try {  37             url =  new File(projectClassPath).toURI().toURL();  38         }  catch (MalformedURLException e) {  39             e.printStackTrace();  40         }  41          return  new URL[] { url };  42     }  43       44      /**

 45       * 重写loadClass，不采用双亲委托机制("java."开头的类还是会由系统默认ClassLoader加载)

 46        */  47     @Override  48      public Class<?> loadClass(String name, boolean resolve)  throws ClassNotFoundException {  49         Class clazz =  null;  50          // 查看HotSwapURLClassLoader实例缓存下，是否已经加载过class

 51           // 不同的HotSwapURLClassLoader实例是不共享缓存的

 52          clazz = findLoadedClass(name);  53          if (clazz !=  null ) {  54              if (resolve){  55                 resolveClass(clazz);  56             }  57              // 如果class类被修改过，则重新加载

 58               if (isModify(name)) {  59                 hcl =  new HotSwapURLClassLoader();  60                 clazz = customLoad(name, hcl);  61             }  62              return (clazz);  63         }  64   65          // 如果类的包名为"java."开始，则有系统默认加载器AppClassLoader加载

 66           if(name.startsWith("java.")){  67              try {  68                  // 得到系统默认的加载cl，即AppClassLoader

 69                  ClassLoader system = ClassLoader.getSystemClassLoader();  70                 clazz = system.loadClass(name);  71                  if (clazz !=  null) {  72                      if (resolve)  73                         resolveClass(clazz);  74                      return (clazz);  75                 }  76             }  catch (ClassNotFoundException e) {  77                  //  Ignore

 78              }  79         }  80           81          return customLoad(name, this);  82     }  83   84      public Class load(String name)  throws Exception{  85          return loadClass(name);  86     }  87   88      /**

 89       * 自定义加载

 90       *  @param  name

 91       *  @param  cl 

 92       *  @return

 93       *  @throws  ClassNotFoundException

 94        */  95      public Class customLoad(String name,ClassLoader cl)  throws ClassNotFoundException {  96          return customLoad(name,  false,cl);  97     }  98   99      /**

100       * 自定义加载

101       *  @param  name

102       *  @param  resolve

103       *  @return

104       *  @throws  ClassNotFoundException

105        */ 106      public Class customLoad(String name,  boolean resolve,ClassLoader cl) 107              throws ClassNotFoundException { 108          // findClass()调用的是URLClassLoader里面重载了ClassLoader的findClass()方法

109          Class clazz = ((HotSwapURLClassLoader)cl).findClass(name); 110          if (resolve) 111             ((HotSwapURLClassLoader)cl).resolveClass(clazz); 112          // 缓存加载class文件的最后修改时间

113           long lastModifyTime = getClassLastModifyTime(name); 114         cacheLastModifyTimeMap.put(name,lastModifyTime); 115          return clazz; 116     } 117      118      public Class<?> loadClass(String name)  throws ClassNotFoundException { 119          return loadClass(name, false); 120     } 121      122     @Override 123      protected Class<?> findClass(String name)  throws ClassNotFoundException { 124          //  TODO Auto-generated method stub

125           return  super.findClass(name); 126     } 127      128      /**

129       *  @param  name

130       *  @return  .class文件最新的修改时间

131        */ 132      private  long getClassLastModifyTime(String name){ 133         String path = getClassCompletePath(name); 134         File file =  new File(path); 135          if(!file.exists()){ 136              throw  new RuntimeException( new FileNotFoundException(name)); 137         } 138          return file.lastModified(); 139     } 140      141      /**

142       * 判断这个文件跟上次比是否修改过

143       *  @param  name

144       *  @return

145        */ 146      private  boolean isModify(String name){ 147          long lastmodify = getClassLastModifyTime(name); 148          long previousModifyTime = cacheLastModifyTimeMap.get(name); 149          if(lastmodify>previousModifyTime){ 150              return  true; 151         } 152          return  false; 153     } 154      155      /**

156       *  @param  name

157       *  @return  .class文件的完整路径 (e.g. E:/A.class)

158        */ 159      private String getClassCompletePath(String name){ 160         String simpleName = name.substring(name.lastIndexOf(".")+1); 161          return projectClassPath+packagePath+simpleName+".class"; 162     } 163      164 } 165 

1  package testjvm.testclassloader; 2  3  public  class Hot { 4      public  void hot(){ 5         System.out.println(" version 1 : "+ this.getClass().getClassLoader()); 6     } 7 } 8 

 1  package testjvm.testclassloader;  2   3  import java.lang.reflect.Method;  4   5  public  class TestHotSwap {  6   7      public  static  void main(String[] args)  throws Exception {  8          // 开启线程，如果class文件有修改，就热替换

 9          Thread t =  new Thread( new MonitorHotSwap()); 10         t.start(); 11     } 12 } 13  14  class MonitorHotSwap  implements Runnable { 15      //  Hot就是用于修改，用来测试热加载

16       private String className = "testjvm.testclassloader.Hot"; 17      private Class hotClazz =  null; 18      private HotSwapURLClassLoader hotSwapCL =  null; 19  20     @Override 21      public  void run() { 22          try { 23              while ( true) { 24                 initLoad(); 25                 Object hot = hotClazz.newInstance(); 26                 Method m = hotClazz.getMethod("hot"); 27                 m.invoke(hot,  null);  // 打印出相关信息

28                   //  每隔10秒重新加载一次

29                  Thread.sleep(10000); 30             } 31         }  catch (Exception e) { 32             e.printStackTrace(); 33         } 34     } 35  36      /**

37       * 加载class

38        */ 39      void initLoad()  throws Exception { 40         hotSwapCL = HotSwapURLClassLoader.getClassLoader(); 41          //  如果Hot类被修改了，那么会重新加载，hotClass也会返回新的

42          hotClazz = hotSwapCL.loadClass(className); 43     } 44 }

  1  package testjvm.testclassloader;   2    3  import java.io.File;   4  import java.net.MalformedURLException;   5  import java.net.URL;   6  import java.net.URLClassLoader;   7    8  public  class SimpleURLClassLoader  extends URLClassLoader {   9      // 工程class类所在的路径

 10       public  static String projectClassPath = "E:/IDE/work_place/ZJob-Note/bin/";  11      // 所有的测试的类都在同一个包下

 12       public  static String packagePath = "testjvm/testclassloader/";  13       14      public SimpleURLClassLoader() {  15          // 设置ClassLoader加载的路径

 16           super(getMyURLs());  17     }  18       19      private  static  URL[] getMyURLs(){  20         URL url =  null;  21          try {  22             url =  new File(projectClassPath).toURI().toURL();  23         }  catch (MalformedURLException e) {  24             e.printStackTrace();  25         }  26          return  new URL[] { url };  27     }  28       29      public Class load(String name)  throws Exception{  30          return loadClass(name);  31     }  32   33      public Class<?> loadClass(String name)  throws ClassNotFoundException {  34          return loadClass(name, false);  35     }  36       37      /**

 38       * 重写loadClass，不采用双亲委托机制("java."开头的类还是会由系统默认ClassLoader加载)

 39        */  40     @Override  41      public Class<?> loadClass(String name, boolean resolve)  throws ClassNotFoundException {  42         Class clazz =  null;  43          // 查看HotSwapURLClassLoader实例缓存下，是否已经加载过class

 44          clazz = findLoadedClass(name);  45          if (clazz !=  null ) {  46              if (resolve){  47                 resolveClass(clazz);  48             }  49              return (clazz);  50         }  51   52          // 如果类的包名为"java."开始，则有系统默认加载器AppClassLoader加载

 53           if(name.startsWith("java.")){  54              try {  55                  // 得到系统默认的加载cl，即AppClassLoader

 56                  ClassLoader system = ClassLoader.getSystemClassLoader();  57                 clazz = system.loadClass(name);  58                  if (clazz !=  null) {  59                      if (resolve)  60                         resolveClass(clazz);  61                      return (clazz);  62                 }  63             }  catch (ClassNotFoundException e) {  64                  //  Ignore

 65              }  66         }  67           68          return customLoad(name, this);  69     }  70   71      /**

 72       * 自定义加载

 73       *  @param  name

 74       *  @param  cl 

 75       *  @return

 76       *  @throws  ClassNotFoundException

 77        */  78      public Class customLoad(String name,ClassLoader cl)  throws ClassNotFoundException {  79          return customLoad(name,  false,cl);  80     }  81   82      /**

 83       * 自定义加载

 84       *  @param  name

 85       *  @param  resolve

 86       *  @return

 87       *  @throws  ClassNotFoundException

 88        */  89      public Class customLoad(String name,  boolean resolve,ClassLoader cl)  90              throws ClassNotFoundException {  91          // findClass()调用的是URLClassLoader里面重载了ClassLoader的findClass()方法

 92          Class clazz = ((SimpleURLClassLoader)cl).findClass(name);  93          if (resolve)  94             ((SimpleURLClassLoader)cl).resolveClass(clazz);  95          return clazz;  96     }  97       98     @Override  99      protected Class<?> findClass(String name)  throws ClassNotFoundException { 100          return  super.findClass(name); 101     } 102 } 103 

1  public  class A {   2  //   public static final Level CUSTOMLEVEL = new Level("test", 550) {};  //  内部类

3  }

 1  package testjvm.testclassloader;  2   3  public  class TestClassUnLoad {  4   5      public  static  void main(String[] args)  throws Exception {  6         SimpleURLClassLoader loader =  new SimpleURLClassLoader();  7          //  用自定义的加载器加载A

 8          Class clazzA = loader.load("testjvm.testclassloader.A");  9         Object a = clazzA.newInstance(); 10          //  清除相关引用

11          a =  null; 12         clazzA =  null; 13         loader =  null; 14          //  执行一次gc垃圾回收

15          System.gc(); 16         System.out.println("GC over"); 17     } 18 } 19 

    1、有启动类加载器加载的类型在整个运行期间是不可能被卸载的(jvm和jls规范).

    2、被系统类加载器和标准扩展类加载器加载的类型在运行期间不太可能被卸载，因为系统类加载器实例或者标准扩展类的实例基本上在整个运行期间总能直接或者间接的访问的到，其达到unreachable的可能性极小.(当然，在虚拟机快退出的时候可以，因为不管ClassLoader实例或者Class(java.lang.Class)实例也都是在堆中存在，同样遵循垃圾收集的规则).

    3、被开发者自定义的类加载器实例加载的类型只有在很简单的上下文环境中才能被卸载，而且一般还要借助于强制调用虚拟机的垃圾收集功能才可以做到.可以预想，稍微复杂点的应用场景中(尤其很多时候，用户在开发自定义类加载器实例的时候采用缓存的策略以提高系统性能)，被加载的类型在运行期间也是几乎不太可能被卸载的(至少卸载的时间是不确定的).

      综合以上三点， 一个已经加载的类型被卸载的几率很小至少被卸载的时间是不确定的.同时，我们可以看的出来，开发者在开发代码时候，不应该对虚拟机的类型卸载做任何假设的前提下来实现系统中的特定功能.