classloader机制对比

http://www.iteye.com/topic/826661

 

tomcat6.0.30 classloader机制 

tomcat相比于jboss4.05概念上简介了很多，不过tomcat 6版本相比于tomcat 5有一些变化，少了一些shared lib库的概念。

 

      Bootstrap
          |
       System
          |
       Common
       /     \
  Webapp1   Webapp2 ... 

 一个树状结构，相信大家差不多都知道tomcat默认是以child first装载class，优先载入web中的class类，找不到才会去装载公用类。

 

 

总结和对比一下(jboss,tomcat,jetty)容器的classloader机制

容器	jboss(4.05)	tomcat(6.0.30)	jetty(7.1.20)
支持child/parent first设置(默认值)	Java2ClassLoadingCompliance=false	delegate=false	_parentLoaderPriority=false
过滤package配置	FilteredPackages 默认值：　javax.servlet,org.apache.commons.logging	packageTriggers 默认配置：org.apache.commons.logging	systemClasses 默认配置：java.  javax. org.xml. org.w3c. org.apache.commons.logging. org.eclipse.jetty.continuation. org.eclipse.jetty.jndi. org.eclipse.jetty.plus.jaas. org.eclipse.jetty.websocket. org.eclipse.jetty.servlet.DefaultServlet.
特殊性	1. UseJBossWebLoader=false时,过滤packages才能生效 2. UseJBossWebLoader=true时,不支持过滤packages 3. jboss 5.0以后UseJBossWebLoader参数将不支持	1. 在执行child/parent判断之前，会委托system classloader装载系统class，比如jdk的lib库	1. 多了一个serverclass配置，如果是serverclass优先采用child first 2. systemclass默认的配置，多了javax,org.xml,org.w3c配置。
相关文档	svn url : http://anonsvn.jboss.org/repos/jbossas/tags/JBoss_4_0_5_GA_CP18 jboss社区classloader文档: http://community.jboss.org/wiki/ClassLoadingConfiguration	svn url : http://svn.apache.org/repos/asf/tomcat/tc6.0.x/trunk 官方classloader机制： http://tomcat.apache.org/tomcat-6.0-doc/class-loader-howto.html	svn url : http://dev.eclipse.org/svnroot/rt/org.eclipse.jetty/jetty/tags/jetty-7.2.0.v20101020/ classloader 官方文档： http://docs.codehaus.org/display/JETTY/Classloading

 

 

---

 

在J2EE的项目中，容器给我们提供的热部署功能使得我们不用重启动容器而修改我们的代码。比如使用Weblogic，我们可以在Weblogic- application.xml中配置是否支持热部署Servlet。查阅Weblogc 文档，其实在Weblogic中，EJB组件也是可以热部署的，但如何要热部署EJB组件，Weblogc要求必须自定义ClassLoder。
    JVM规范中没有指定JVM支持动态加载修改过的类。类的加载，卸载对于程序员是透明的。如果我们要实现类的动态加载我们就要理解JVM本身类的加载与卸载的原理，实现热部署。对于JVM加载类方面的资料在网上很多的，在这里我做简单概述：
    （1）JVM加载时通过ClassLoader加载的。
    （2）JVM有3层继承关系的ClassLoder 分别是：
                                       -----BootStrap类加载器 加载JRE/lib
                                                -----------------ExtClassLoader 加载 JRE /lib/ext
                                                           ----------AppClassLoader 加载ClassPath/
    (3)为了安全性，JVM加载采用了双亲委派机制，如何理解呢，就是当需要加载一个类时，当前的ClassLoader先请求父ClassLoader，依次
      类推，直到父类的ClassLoader无法加载时，才通过当前的ClassLoser加载，这就保证了像String这样的类型必须使用JRE里面的， 使得
      JRE lib 下类不会被修改。同时避免了ClassCaseException。
   （4）在JVM中，一个实例是通过本身的类名+加载它的ClassLoader识别的，也就是说 不同的ClassLoader 加载同一个类在JVM是不同的。
   （5）同一个ClassLoader是不允许多次加载一个类的，否则会报java.lang.LinkageError。attempted duplicate class definition for
   name XXX，在下面的例子中会指出。
    既然JVM不支持热部署，那么要实现热部署，就必须自定义ClassLoader，当类被修改过后，加载该类。下面通过代码说明：

package classloader;

/**
* @author vma
*/
// 自定义一个类加载器
public class DynamicClassLoader extends ClassLoader {
    
  
     public Class <?> findClass( byte [] b) throws ClassNotFoundException {

         return defineClass( null , b, 0 , b.length);
     }

package classloader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/**
* @author vma
*/
public class ManageClassLoader {
     DynamicClassLoader dc = null ;
    
     Long lastModified = 0l ;
     Class c = null ;
    //加载类， 如果类文件修改过加载，如果没有修改，返回当前的
     public Class loadClass(String name) throws ClassNotFoundException, IOException{
      if (isClassModified(name)){
         dc =    new DynamicClassLoader();
       return c = dc.findClass(getBytes(name));
      }
      return c;
     }
    //判断是否被修改过
     private boolean isClassModified(String filename) {
         boolean returnValue = false ;
         File file = new File(filename);
         if (file.lastModified() > lastModified) {
             returnValue = true ;
         }
         return returnValue;
     }
       // 从本地读取文件
        private byte [] getBytes(String filename) throws IOException {
         File file = new File(filename);
         long len = file.length();
         lastModified = file.lastModified();
         byte raw[] = new byte [( int ) len];
         FileInputStream fin = new FileInputStream(file);
         int r = fin.read(raw);
         if (r != len) {
             throw new IOException( " Can't read all, " + r + " != " + len);
         }
         fin.close();
         return raw;
     }
}

测试类；Main 每隔 5s 加载一次

package classloader;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
*
* @author vma
*/
public class Main {

     /**
      * @param args the command line arguments
      */
     public static void main(String[] args) throws ClassNotFoundException, IOException, NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException, InterruptedException {
         String path = " D://deploy//JDBC//ClassLoader//build//classes//classloader//LocalClass.class " ;
         ManageClassLoader mc = new ManageClassLoader();
         while ( true ){
        Class c = mc.loadClass(path);
         Object o = c.newInstance();
        Method m = c.getMethod( " getName " );
         m.invoke(o);
         System.out.println(c.getClassLoader());
         Thread.sleep( 5000 );
         }


     }

被加载的类

/**
*
* @author vma
*/
public class LocalClass {

     public void getName() {
        
       System.out.println( " hahaha " );
     }
}

运行时,每隔5s 输出：
hahaha
classloader.DynamicClassLoader@61de33
当我们修改 System.out.println( " hahaha " ); ---> System.out.println( " changed " ); 编译LocalClass后
输出变为：
changed
classloader.DynamicClassLoader@173a10f

在loadClass 中， 我们必须重新初始化一个ClassLoader,负责就会违背同一个ClassLoader是不允许多次加载一个类的。
    public Class loadClass(String name) throws ClassNotFoundException, IOException{
      if (isClassModified(name)){
         dc =    new DynamicClassLoader();
       return c = dc.findClass(getBytes(name));
      }
      return c;
     }
当然，容器的实现机制肯定及其完善，不可能周期性的加载，可能回通过监听机制，动态加载修改过的类。但它的实现机制肯定也是重新
实例化一个ClassLoder，加载需要加载的类。