死磕tomcat源码(二)之类加载体系

前言

Tomcat遵循J2EE规范，实现了Web容器。很多有关web的书籍和文章都离不开对Tomcat的分析，初学者可以从Tomcat的实现对J2EE有更深入的了解。此外，Tomcat还根据Java虚拟机规范实现了经典的双亲委派模式的类加载体系。本文基于Tomcat7.0的Java源码，对其类加载体系进行分析。

概述

首先简单介绍下Java虚拟机规范中提到的主要类加载器；

Bootstrap Loader：启动类加载器主要加载的是JVM自身需要的类，这个类加载使用C++语言实现的，是虚拟机自身的一部分，它负责将 /lib路径下的核心类库或-Xbootclasspath参数指定的路径下的jar包加载到内存中，注意必由于虚拟机是按照文件名识别加载jar包的，如rt.jar，如果文件名不被虚拟机识别，即使把jar包丢到lib目录下也是没有作用的(出于安全考虑，Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类)。
Extended Loader：扩展类加载器是指Sun公司(已被Oracle收购)实现的sun.misc.Launcher$ExtClassLoader类，由Java语言实现的，是Launcher的静态内部类，它负责加载/lib/ext目录下或者由系统变量-Djava.ext.dir指定位路径中的类库，开发者可以直接使用标准扩展类加载器。
AppClass Loader：也称应用程序加载器是指 Sun公司实现的sun.misc.Launcher$AppClassLoader。它负责加载系统类路径java -classpath或-D java.class.path 指定路径下的类库，也就是我们经常用到的classpath路径，开发者可以直接使用系统类加载器，一般情况下该类加载是程序中默认的类加载器，通过ClassLoader#getSystemClassLoader()方法可以获取到该类加载器。

根据java虚拟机的双亲委派模式的原则，类加载器在加载一个类时，首先交给父类加载器加载，层层往上直到Bootstrap Loader。也就是一个类最先由Bootstrap Loader加载，如果没有加载到，则交给下一层的类加载器加载，如果没有加载到，则依次层层往下，直到最下层的类加载器。这也就是说，凡是能通过父一级类加载器加载到的类，对于子类也是可见的。因此可以利用双亲委派模式的特性，使用类加载器对不同路径下的jar包或者类进行环境隔离。

然后用一张图片来展示Tomcat的类加载体系：

这里结合之前对双亲委派模式的类加载过程的描述，对上图所示类加载体系进行介绍：
ClassLoader：Java提供的类加载器抽象类，用户自定义的类加载器需要继承实现
commonLoader：Tomcat最基本的类加载器，加载路径中的class可以被Tomcat容器本身以及各个Webapp访问；
catalinaLoader：Tomcat容器私有的类加载器，加载路径中的class对于Webapp不可见；
sharedLoader：各个Webapp共享的类加载器，加载路径中的class对于所有Webapp可见，但是对于Tomcat容器不可见；

WebappClassLoader：各个Webapp私有的类加载器，加载路径中的class只对当前Webapp可见；

源码分析

commonLoader、catalinaLoader和sharedLoader在Tomcat容器初始化的一开始，即调用Bootstrap的init方法时创建。catalinaLoader会被设置为Tomcat主线程的线程上下文类加载器，并且使用catalinaLoader加载Tomcat容器自身容器下的class。Bootstrap的init方法的部分代码见代码清单1。

代码清单1 Bootstrap的init方法的部分实现 :

    /**
     * Initialize daemon.
     */
    public void init()
        throws Exception
    {

        // Set Catalina path
        setCatalinaHome();
        setCatalinaBase();

        initClassLoaders();

        Thread.currentThread().setContextClassLoader(catalinaLoader);

        SecurityClassLoad.securityClassLoad(catalinaLoader);
        // 省略后边的代码

代码清单1中，我们首先关注initClassLoaders方法的实现，见代码清单2.initClassLoaders方法用来初始化commonLoader、catalinaLoader、sharedLoader。

代码清单2 initClassLoaders方法的实现:

private void initClassLoaders() {  
    try {  
        commonLoader = createClassLoader("common", null);  
        if( commonLoader == null ) {  
            // no config file, default to this loader - we might be in a 'single' env.  
            commonLoader=this.getClass().getClassLoader();  
        }  
        catalinaLoader = createClassLoader("server", commonLoader);  
        sharedLoader = createClassLoader("shared", commonLoader);  
    } catch (Throwable t) {  
        log.error("Class loader creation threw exception", t);  
        System.exit(1);  
    }  
}

从代码清单2中看到创建类加载器是通过调用createClassLoader方法实现的，createClassLoader的实现见代码清单3.

private ClassLoader createClassLoader(String name, ClassLoader parent)  
    throws Exception {  
  
    String value = CatalinaProperties.getProperty(name + ".loader");  
    if ((value == null) || (value.equals("")))  
        return parent;  
  
    ArrayList repositoryLocations = new ArrayList();  
    ArrayList repositoryTypes = new ArrayList();  
    int i;  
  
    StringTokenizer tokenizer = new StringTokenizer(value, ",");  
    while (tokenizer.hasMoreElements()) {  
        String repository = tokenizer.nextToken();  
  
        // Local repository  
        boolean replace = false;  
        String before = repository;  
        while ((i=repository.indexOf(CATALINA_HOME_TOKEN))>=0) {  
            replace=true;  
            if (i>0) {  
            repository = repository.substring(0,i) + getCatalinaHome()   
                + repository.substring(i+CATALINA_HOME_TOKEN.length());  
            } else {  
                repository = getCatalinaHome()   
                    + repository.substring(CATALINA_HOME_TOKEN.length());  
            }  
        }  
        while ((i=repository.indexOf(CATALINA_BASE_TOKEN))>=0) {  
            replace=true;  
            if (i>0) {  
            repository = repository.substring(0,i) + getCatalinaBase()   
                + repository.substring(i+CATALINA_BASE_TOKEN.length());  
            } else {  
                repository = getCatalinaBase()   
                    + repository.substring(CATALINA_BASE_TOKEN.length());  
            }  
        }  
        if (replace && log.isDebugEnabled())  
            log.debug("Expanded " + before + " to " + repository);  
  
        // Check for a JAR URL repository  
        try {  
            new URL(repository);  
            repositoryLocations.add(repository);  
            repositoryTypes.add(ClassLoaderFactory.IS_URL);  
            continue;  
        } catch (MalformedURLException e) {  
            // Ignore  
        }  
  
        if (repository.endsWith("*.jar")) {  
            repository = repository.substring  
                (0, repository.length() - "*.jar".length());  
            repositoryLocations.add(repository);  
            repositoryTypes.add(ClassLoaderFactory.IS_GLOB);  
        } else if (repository.endsWith(".jar")) {  
            repositoryLocations.add(repository);  
            repositoryTypes.add(ClassLoaderFactory.IS_JAR);  
        } else {  
            repositoryLocations.add(repository);  
            repositoryTypes.add(ClassLoaderFactory.IS_DIR);  
        }  
    }  
  
    String[] locations = repositoryLocations.toArray(new String[0]);  
    Integer[] types = repositoryTypes.toArray(new Integer[0]);  
  
    ClassLoader classLoader = ClassLoaderFactory.createClassLoader  
        (locations, types, parent);  
  
    // Retrieving MBean server  
    MBeanServer mBeanServer = null;  
    if (MBeanServerFactory.findMBeanServer(null).size() > 0) {  
        mBeanServer = MBeanServerFactory.findMBeanServer(null).get(0);  
    } else {  
        mBeanServer = ManagementFactory.getPlatformMBeanServer();  
    }  
  
    // Register the server classloader  
    ObjectName objectName =  
        new ObjectName("Catalina:type=ServerClassLoader,name=" + name);  
    mBeanServer.registerMBean(classLoader, objectName);  
  
    return classLoader;  
  
}

createClassLoader方法的执行步骤如下：

获取各个类加载器相应的资源配置文件（分别为common.loader、server.loader、shared.loader），从中获取类资源路径的配置信息；
解析类资源路径下的各个资源位置和类型，也包括对jar资源的检查；
调用ClassLoaderFactory.createClassLoader(locations, types, parent)方法创建ClassLoader；
将ClassLoader注册到JMX服务中。

我们回头看看代码清单1中的SecurityClassLoad.securityClassLoad(catalinaLoader)的实现，见代码清单4.这说明加载Tomcat容器本身的类资源的确是使用catalinaLoader来完成的。

代码清单4 securityClassLoad的实现:

public static void securityClassLoad(ClassLoader loader)  
    throws Exception {  
  
    if( System.getSecurityManager() == null ){  
        return;  
    }  
      
    loadCorePackage(loader);  
    loadLoaderPackage(loader);  
    loadSessionPackage(loader);  
    loadUtilPackage(loader);  
    loadJavaxPackage(loader);  
    loadCoyotePackage(loader);          
    loadTomcatPackage(loader);  
}

securityClassLoad方法主要加载Tomcat容器所需的class，包括：

Tomcat核心class，即org.apache.catalina.core路径下的class；
org.apache.catalina.loader.WebappClassLoader$PrivilegedFindResourceByName；
Tomcat有关session的class，即org.apache.catalina.session路径下的class；
Tomcat工具类的class，即org.apache.catalina.util路径下的class；
javax.servlet.http.Cookie；
Tomcat处理请求的class，即org.apache.catalina.connector路径下的class；
Tomcat其它工具类的class，也是org.apache.catalina.util路径下的class；
我们以加载Tomcat核心class的loadCorePackage方法为例，其实现见代码清单5所示。

代码清单5 loadCorePackage的实现:

private final static void loadCorePackage(ClassLoader loader)  
    throws Exception {  
    String basePackage = "org.apache.catalina.";  
    loader.loadClass  
        (basePackage +  
         "core.ApplicationContextFacade$1");  
    loader.loadClass  
        (basePackage +  
         "core.ApplicationDispatcher$PrivilegedForward");  
    loader.loadClass  
        (basePackage +  
         "core.ApplicationDispatcher$PrivilegedInclude");  
    loader.loadClass  
        (basePackage +  
        "core.AsyncContextImpl");  
    loader.loadClass  
        (basePackage +  
        "core.AsyncContextImpl$AsyncState");  
    loader.loadClass  
        (basePackage +  
        "core.AsyncContextImpl$DebugException");  
    loader.loadClass  
        (basePackage +  
        "core.AsyncContextImpl$1");  
    loader.loadClass  
        (basePackage +  
        "core.AsyncContextImpl$2");  
    loader.loadClass  
        (basePackage +  
        "core.AsyncListenerWrapper");  
    loader.loadClass  
        (basePackage +  
         "core.ContainerBase$PrivilegedAddChild");  
    loader.loadClass  
        (basePackage +  
         "core.DefaultInstanceManager$1");  
    loader.loadClass  
        (basePackage +  
         "core.DefaultInstanceManager$2");  
    loader.loadClass  
        (basePackage +  
         "core.DefaultInstanceManager$3");  
    loader.loadClass  
        (basePackage +  
         "core.DefaultInstanceManager$4");  
    loader.loadClass  
        (basePackage +  
         "core.DefaultInstanceManager$5");  
    loader.loadClass  
        (basePackage +  
         "core.ApplicationHttpRequest$AttributeNamesEnumerator");  
}

至此，有关commonLoader、catalinaLoader和sharedLoader三个类加载器的初始化以及使用catalinaLoader加载Tomcat容器自身类资源的内容已经介绍完了，WebappClassLoader下次补上。

死磕tomcat源码(二)之类加载体系

前言

概述

源码分析

你可能感兴趣的:(死磕tomcat源码(二)之类加载体系)