Tomcat7.0源码分析——类加载体系

最新推荐文章于 2022-05-22 19:41:18 发布
最新推荐文章于 2022-05-22 19:41:18 发布
阅读量74 收藏
点赞数
文章标签： java 大数据
原文链接：https://yq.aliyun.com/articles/632478
版权
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/beliefer/article/details/50995516

前言

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

概述

首先简单介绍下Java虚拟机规范中提到的主要类加载器；
  • Bootstrap Loader：加载lib目录下或者System.getProperty(“sun.boot.class.path”)、或者-XBootclasspath所指定的路径或jar。
  • Extended Loader：加载lib\ext目录下或者System.getProperty(“java.ext.dirs”) 所指定的 路径或jar。在使用Java运行程序时，也可以指定其搜索路径，例如：java -Djava.ext.dirs=d:\projects\testproj\classes HelloWorld。
  • AppClass Loader：加载System.getProperty("java.class.path")所指定的 路径或jar。在使用Java运行程序时，也可以加上-cp来覆盖原有的Classpath设置，例如： java -cp ./lavasoft/classes HelloWorld。
根据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.

代码清单3 createClassLoader方法的实现

    private ClassLoader createClassLoader(String name, ClassLoader parent)
        throws Exception {

        String value = CatalinaProperties.getProperty(name + ".loader");
        if ((value == null) || (value.equals("")))
            return parent;

        ArrayList<String> repositoryLocations = new ArrayList<String>();
        ArrayList<Integer> repositoryTypes = new ArrayList<Integer>();
        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方法的执行步骤如下：

  1. 获取各个类加载器相应的资源配置文件（分别为common.loader、server.loader、shared.loader），从中获取类资源路径的配置信息；
  2. 解析类资源路径下的各个资源位置和类型，也包括对jar资源的检查；
  3. 调用ClassLoaderFactory.createClassLoader(locations, types, parent)方法创建ClassLoader；
  4. 将ClassLoader注册到JMX服务中，有个JMX的内容可以参照《Tomcat7.0源码分析——生命周期管理 》一文中的相关介绍。

我们回头看看代码清单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。启动StandardContext的时候会创建WebappLoader，根据《Tomcat7.0源码分析——生命周期管理 》一文的内容，我们知道启动StandardContext时会最终调用其startInternal方法，其实现见代码清单6.

代码清单6 StandardContext的startInternal方法

    /**
     * Start this component and implement the requirements
     * of {@link LifecycleBase#startInternal()}.
     *
     * @exception LifecycleException if this component detects a fatal error
     *  that prevents this component from being used
     */
    @Override
    protected synchronized void startInternal() throws LifecycleException {

        // 省略前边的代码 

        if (getLoader() == null) {
            WebappLoader webappLoader = new WebappLoader(getParentClassLoader());
            webappLoader.setDelegate(getDelegate());
            setLoader(webappLoader);
        }
       // 省略中间的代码 
       // Start our subordinate components, if any
       if ((loader != null) && (loader instanceof Lifecycle))
            ((Lifecycle) loader).start(); 
       // 省略后边的代码 
    }

 从代码清单6看到首先创建WebappLoader实例，然后调用WebappLoader的start方法，start又调用了startInternal方法，WebappLoader的startInternal的实现见代码清单7.

代码清单7 WebappLoader的startInternal实现

    /**
     * Start associated {@link ClassLoader} and implement the requirements
     * of {@link LifecycleBase#startInternal()}.
     *
     * @exception LifecycleException if this component detects a fatal error
     *  that prevents this component from being used
     */
    @Override
    protected void startInternal() throws LifecycleException {
        
        // Register a stream handler factory for the JNDI protocol
        URLStreamHandlerFactory streamHandlerFactory =
            new DirContextURLStreamHandlerFactory();
        if (first) {
            first = false;
            try {
                URL.setURLStreamHandlerFactory(streamHandlerFactory);
            } catch (Exception e) {
                // Log and continue anyway, this is not critical
                log.error("Error registering jndi stream handler", e);
            } catch (Throwable t) {
                // This is likely a dual registration
                log.info("Dual registration of jndi stream handler: " 
                         + t.getMessage());
            }
        }

        // Construct a class loader based on our current repositories list
        try {

            classLoader = createClassLoader();
            classLoader.setResources(container.getResources());
            classLoader.setDelegate(this.delegate);
            classLoader.setSearchExternalFirst(searchExternalFirst);
            if (container instanceof StandardContext) {
                classLoader.setAntiJARLocking(
                        ((StandardContext) container).getAntiJARLocking());
                classLoader.setClearReferencesStatic(
                        ((StandardContext) container).getClearReferencesStatic());
                classLoader.setClearReferencesStopThreads(
                        ((StandardContext) container).getClearReferencesStopThreads());
                classLoader.setClearReferencesStopTimerThreads(
                        ((StandardContext) container).getClearReferencesStopTimerThreads());
                classLoader.setClearReferencesThreadLocals(
                        ((StandardContext) container).getClearReferencesThreadLocals());
            }

            for (int i = 0; i < repositories.length; i++) {
                classLoader.addRepository(repositories[i]);
            }

 我们看到代码清单7中通过调用createClassLoader来创建类加载器，并且设置其资源路径为当前Webapp下某个context的类资源。最后我们看看createClassLoader的实现，见代码清单8.

代码清单8 createClassLoader的实现

    /**
     * Create associated classLoader.
     */
    private WebappClassLoader createClassLoader()
        throws Exception {

        //loaderClass即字符串org.apache.catalina.loader.WebappClassLoader
        Class<?> clazz = Class.forName(loaderClass);
        WebappClassLoader classLoader = null;

        if (parentClassLoader == null) {
            parentClassLoader = container.getParentClassLoader();
        }
        Class<?>[] argTypes = { ClassLoader.class };
        Object[] args = { parentClassLoader };
        Constructor<?> constr = clazz.getConstructor(argTypes);
        classLoader = (WebappClassLoader) constr.newInstance(args);

        return classLoader;

    }

 这里loaderClass的值是字符串org.apache.catalina.loader.WebappClassLoader，通过反射来实例化WebappClassLoader。由于每个Webapp下的类资源由不同的WebappClassLoader负责加载，因此Webapp下各个Context的类资源是独立的。至此，整个Tomcat的类加载体系构建完毕。

此外每个jsp为了实现热替换，会有专门的类加载器负责加载。


后记：个人总结整理的《深入理解Spark：核心思想与源码分析》一书现在已经正式出版上市，目前京东、当当、天猫等网站均有销售，欢迎感兴趣的同学购买。


京东：http://item.jd.com/11846120.html 

当当：http://product.dangdang.com/23838168.html 


weixin_33939843
关注
Tomcat内核之Tomcat的类加载器
seaboat——a free boat on the sea.（公众号：远洋号）
12-14 4929
跟其他主流的Java Web服务器一样，Tomcat也拥有不同的自定义类加载器，达到对各种资源库的控制。一般来说，Java Web服务器需要解决以下四个问题： ①   同一个Web服务器里，各个Web项目之间各自使用的Java类库要互相隔离。 ②   同一个Web服务器里，各个Web项目之间可以提供共享的Java类库。 ③   服务器为了不受Web项目的影响，应该使服务器的类库与应用程序的类
Tomcat7.0源码分析——启动与停止服务原理
beliefer的博客
06-07 1万+
熟悉Tomcat的工程师们，肯定都知道Tomcat是如何启动与停止的。对于startup.sh、startup.bat、shutdown.sh、shutdown.bat等脚本或者批处理命令，大家一定知道改如何使用它，但是它们究竟是如何实现的，尤其是shutdown.sh脚本（或者shutdown.bat）究竟是如何和Tomcat进程通信的呢？本文将通过对Tomcat7.0的源码阅读，深入剖析这一过程。
Tomcat源码分析——请求原理分析（下）
weixin_30455023的博客
10-23 195
前言 　　本文继续讲解TOMCAT的请求原理分析，建议朋友们阅读本文时首先阅读过《TOMCAT源码分析——请求原理分析（上）》和《TOMCAT源码分析——请求原理分析（中）》。在《TOMCAT源码分析——请求原理分析（中）》一文我简单讲到了Pipeline，但并未完全展开，本文将从Pipeline开始讲解请求原理的剩余内容。 管道 　　在Tomcat中管道Pipeline是一个接口...
Tomcat源码分析——类加载体系
weixin_33943347的博客
03-15 88
前言 Tomcat遵循J2EE规范，实现了Web容器。很多有关web的书籍和文章都离不开对Tomcat的分析，初学者可以从Tomcat的实现对J2EE有更深入的了解。此外，Tomcat还根据Java虚拟机规范实现了经典的双亲委派模式的类加载体系。本文基于Tomcat7.0的Java源码，对其类加载体系进行分析。 概述 首先简单介绍下Java虚拟机规范中提...
[转]Tomcat类加载机制
ryudoooo的博客
11-22 123
TOMCAT源码分析(启动框架) TOMCAT源码分析(消息处理) yahoo中国的一个面试题，转至水木，希望对大家有用. Tomcat Server在启动的时候将构造一个ClassLoader树，以保证模块的类库是私有的 Tomcat Server的ClassLoader结构如下： 代码     Bootstrap           |              ...
Tomcat7.0源码分析——请求原理分析（下）
beliefer的博客
07-28 1万+
本文继续讲解TOMCAT的请求原理分析，建议朋友们阅读本文时首先阅读过《Tomcat7.0源码分析——请求原理分析（上）》和《Tomcat7.0源码分析——请求原理分析（中）》。在《Tomcat7.0源码分析——请求原理分析（中）》一文我简单讲到了Pipeline，但并未完全展开，本文将从Pipeline开始讲解请求原理的剩余内容。
Tomcat7.0源码分析——请求原理分析（上）
热门推荐
beliefer的博客
06-30 3万+
谈起Tomcat的诞生，最早可以追溯到1995年。近20年来，Tomcat始终是使用最广泛的Web服务器，由于其使用Java语言开发，所以广为Java程序员所熟悉。很多人早期的J2EE项目，由程序员自己实现Jsp页面或者Servlet接受请求，后来借助Struts1、Struts2、Spring等中间件后，实际也是利用Filter或者Servlet处理请求，大家肯定要问了，这些Servlet处理的请求来自哪里？Tomcat作为Web服务器是怎样将HTTP请求交给Servlet的呢？
Tomcat7.0源码分析——server.xml文件的加载与解析
beliefer的博客
04-01 1万+
作为Java程序员，对于tomcat的server.xml想必都不陌生。本文基于Tomcat7.0的Java源码，对server.xml文件是如何加载和解析进行分析。
Tomcat完整笔记
weixin_40212405的博客
10-12 931
1. Tomcat的安装和配置环境变量 安装 到官网下载需要的Tomcat版本的压缩包即可 注意：Tomcat 9 对应的JRE必须>=JRE 8；Tomcat 8 7同理 然后解压到指定的文件夹；目录名为：“apache-tomcat-[version]” （WINDOWS和Linux）一样的效果 配置环境变量 配置JRE环境变量，变量名为：CATALINA_HOME（required)和...
Tomcat 的类加载机制
张维鹏的博客
10-16 7840
Tomcat 实际上只有WebAppClassLoader 加载器中打破了双亲委派，其他类加载器还是遵循双亲委派的。 这样做最主要原因是保证同个 Web 容器中的不同 Web 应用程序所使用的类库相互独立，避免相互影响
tomcat的类加载机制
simplemeet的博客
04-21 319
tomcat的类加载机制遵循了java类加载机制中经典的双亲委派模型。所以要了解tomcat的类加载机制需要先了解双亲委派模型。 双亲委派模型 java的双亲委派模型如下图所示（组合方式实现继承关系）： Bootstrap类加载器：负责加载jre/lib下的jar，例如rt.jar是java的核心类库，Object、String、System等常用类都存在于rt.jar中。这个加载器存在于虚拟机...
tomcat的类加载器
wangziman的博客
04-21 767
Tomcat的类加载机制是违反了双亲委托原则的，对于一些未加载的非基础类(Object,String等)，各个web应用自己的类加载器(WebAppClassLoader)会优先加载，加载不到时再交给commonClassLoader走双亲委托。 对于JVM来说： 因此，按照这个过程可以想到，如果同样在CLASSPATH指定的目录中和自己工作目录中存放相同的class，会优先加载CLASSPATH...
Tomcat类加载器
weixin_38441454的博客
05-22 801
java标准类加载器 Bootstrap：用于加载JVM提供的基础运行类，即位于%JAVA_HOME%/jre/lib目录下的核心类库。 Extension：加载除核心类库外的Jar包，即只要复制到指定的扩展目录下的Jar，默认的扩展目录是%JAVA_HOME%/jre/lib/ext。 System：用于加载环境变量CLASSPATH指定目录下的或者-classpath运行参数指定的Jar包。System类加载器通常...
tomcat学习|tomcat中的类加载器
微笑的小小刀
08-21 198
开头说两句小刀博客:http://www.lixiang.red小刀公众号: 程序员学习大本营学习背景上期我们聊到了tomcat中各个组件在默认值,在其中,我们看到了有关类加载器的代码...
图解Tomcat类加载机制
xingoo
06-14 570
　　说到本篇的tomcat类加载机制，不得不说翻译学习tomcat的初衷。 　　之前实习的时候学习javaMelody的源码，但是它是一个Maven的项目，与我们自己的web项目整合后无法直接断点调试。后来同事指导，说是直接把java类复制到src下就可以了。很纳闷....为什么会优先加载src下的java文件（编译出的class），而不是jar包中的class呢？ 　　现在了解...
tomcat类加载体系
风的博客
09-09 624
jvm中有一个很重要的模块，就是类加载机制，而且由于其双亲加载机制的设计，保证了java核心库的安全性，更进一步，保证了共享对象这一机制，从而达到信息的高度共享。有意思的是，java的ClassLoader并不是final的，也就是我们完全可以通过继承它而改写这个类加载体系，tomcat就是这么做的。这篇博客就是来介绍tomcat为了实现其实际的需求，改写类加载体系的。
深入探索Apache Tomcat 7.0.99源码解析
版本7.0.99是Tomcat的一个特定版本，提供了源码级别的访问，使得开发者可以深入地研究和理解Tomcat的工作机制，进行定制化开发或者直接阅读源码来学习如何构建高性能的Web服务器。 Tomcat 7主要实现了Servlet 3.0和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值