tomcat10.1.0源码分析

已于 2022-11-22 13:51:00 修改
阅读量719 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java 文章标签： servlet tomcat java
于 2022-11-01 17:54:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/WangMapleWang/article/details/127627752
本文深入解析Tomcat服务器架构，包括组件结构、启动流程、请求处理机制等关键内容，并详细介绍了类加载器的工作原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

组件成员

server.xml

<?xml version='1.0' encoding='utf-8'?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at
 
      http://www.apache.org/licenses/LICENSE-2.0
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->
<!-- Note:  A "Server" is not itself a "Container", so you may not
     define subcomponents such as "Valves" at this level.
     Documentation at /docs/config/server.html
 -->
<Server port="8005" shutdown="SHUTDOWN">
  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
  <!-- Security listener. Documentation at /docs/config/listeners.html
  <Listener className="org.apache.catalina.security.SecurityListener" />
  -->
  <!--APR library loader. Documentation at /docs/apr.html -->
  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
  <!-- Prevent memory leaks due to use of particular java/javax APIs-->
  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
 
  <!-- Global JNDI resources
       Documentation at /docs/jndi-resources-howto.html
  -->
  <GlobalNamingResources>
    <!-- Editable user database that can also be used by
         UserDatabaseRealm to authenticate users
    -->
    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
              description="User database that can be updated and saved"
              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
              pathname="conf/tomcat-users.xml" />
  </GlobalNamingResources>
 
  <!-- A "Service" is a collection of one or more "Connectors" that share
       a single "Container" Note:  A "Service" is not itself a "Container",
       so you may not define subcomponents such as "Valves" at this level.
       Documentation at /docs/config/service.html
   -->
  <Service name="Catalina">
 
    <!--The connectors can use a shared executor, you can define one or more named thread pools-->
    <!--
    <Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
        maxThreads="150" minSpareThreads="4"/>
    -->
 
 
    <!-- A "Connector" represents an endpoint by which requests are received
         and responses are returned. Documentation at :
         Java HTTP Connector: /docs/config/http.html (blocking & non-blocking)
         Java AJP  Connector: /docs/config/ajp.html
         APR (HTTP/AJP) Connector: /docs/apr.html
         Define a non-SSL/TLS HTTP/1.1 Connector on port 8080
    -->
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    <!-- A "Connector" using the shared thread pool-->
    <!--
    <Connector executor="tomcatThreadPool"
               port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    -->
    <!-- Define a SSL/TLS HTTP/1.1 Connector on port 8443
         This connector uses the NIO implementation that requires the JSSE
         style configuration. When using the APR/native implementation, the
         OpenSSL style configuration is required as described in the APR/native
         documentation -->
    <!--
    <Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
               maxThreads="150" SSLEnabled="true" scheme="https" secure="true"
               clientAuth="false" sslProtocol="TLS" />
    -->
 
    <!-- Define an AJP 1.3 Connector on port 8009 -->
    <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
 
 
    <!-- An Engine represents the entry point (within Catalina) that processes
         every request.  The Engine implementation for Tomcat stand alone
         analyzes the HTTP headers included with the request, and passes them
         on to the appropriate Host (virtual host).
         Documentation at /docs/config/engine.html -->
 
    <!-- You should set jvmRoute to support load-balancing via AJP ie :
    <Engine name="Catalina" defaultHost="localhost" jvmRoute="jvm1">
    -->
    <Engine name="Catalina" defaultHost="localhost">
 
      <!--For clustering, please take a look at documentation at:
          /docs/cluster-howto.html  (simple how to)
          /docs/config/cluster.html (reference documentation) -->
      <!--
      <Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>
      -->
 
      <!-- Use the LockOutRealm to prevent attempts to guess user passwords
           via a brute-force attack -->
      <Realm className="org.apache.catalina.realm.LockOutRealm">
        <!-- This Realm uses the UserDatabase configured in the global JNDI
             resources under the key "UserDatabase".  Any edits
             that are performed against this UserDatabase are immediately
             available for use by the Realm.  -->
        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
               resourceName="UserDatabase"/>
      </Realm>
 
      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">
 
        <!-- SingleSignOn valve, share authentication between web applications
             Documentation at: /docs/config/valve.html -->
        <!--
        <Valve className="org.apache.catalina.authenticator.SingleSignOn" />
        -->
 
        <!-- Access log processes all example.
             Documentation at: /docs/config/valve.html
             Note: The pattern used is equivalent to using pattern="common" -->
        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
               prefix="localhost_access_log" suffix=".txt"
               pattern="%h %l %u %t "%r" %s %b" />
 
      </Host>
    </Engine>
  </Service>
</Server>

server

代表一个tomcat实例，可包含多个service，管理所有的service生命周期

service

包含多个connector和一个container

container

容器:负责处理请求

engine

只有一个，可包含多个host

host

虚拟主机，虚拟主机允许Tomcat引擎在将配置在一台机器上的多个域名

context

每个虚拟主机又可以支持多个web应用部署在它下边，这就是我们所熟知的上下文对象

wrapper

在上下文中又可以部署多个servlet，并且每个servlet都会被一个包装组件（Wrapper）所包含（一个wrapper对应一个servlet）

在这里插入图片描述
在这里插入图片描述

connector

连接器：负责接收请求,处理与客户端的通信，传递给container
Tomcat源码中与connector相关的类位于org.apache.coyote包中，Connector分为以下几类：

Http Connector

基于HTTP协议，负责建立HTTP连接。它又分为BIO Http Connector与NIO Http Connector两种，后者提供非阻塞IO与长连接Comet支持。默认情况下，Tomcat使用的就是这个Connector。

AJP Connector

基于AJP协议，AJP是专门设计用来为tomcat与http服务器之间通信专门定制的协议，能提供较高的通信速度和效率。如与Apache服务器集成时，采用这个协议。

APR HTTP Connector

用C实现，通过JNI调用的。主要提升对静态资源(如HTML、图片、CSS、JS等)的访问性能。现在这个库已独立出来可用在任何项目中。Tomcat在配置APR之后性能非常强劲

Connector的三种运行模式: bio nio apr

在这里插入图片描述

Endpoint

实现了建立连接、处理连接、和关闭连接等操作

在这里插入图片描述

Pipeline & Value

在Catalina中，我们有4种容器，request请求在这4个容器中流转，容器间不是直接调用，而是通过pipeline组件，每个容器都有自己的Pipeline组件，每个Pipeline组件上至少会设定一个Valve(阀门)，这个Valve我们称之为BaseValve（基础阀）。可以说基础阀是两个容器之间的桥梁。
在这里插入图片描述

图中可以看到在同一个Pipeline上可以有多个Valve,每个Valve都可以做一些操作，无论是Pipeline还是Valve操作的都是Request和Response。而在容器之间Pipeline和Valve则起到了桥梁的作用

初始化

catalina组件初始化阶段调用createStartDigester创建Digester对象，解析server.xml规则，实例化组件对象并部分赋值。（反射）

bootstrap 创建catalina 使用反射

Catalina及它依赖的类比如 XML parser与应用级别的类隔离（以使用不同类加载器的方法），

Catalina是由catalinaLoader加载的，而Bootstrap是由AppClassLoader加载的，所以在Bootstrap中我们无法直接调用Catalina的方法

bootstrap 加载一些公共类、配置环境、实例化Catalina类，具体的业务代码还是在catalina类里面的。这样反射的好处是解耦，可以不依赖应用层的classpath独立加载

在这里插入图片描述

tomcat启动过程

在这里插入图片描述

url请求流程

在这里插入图片描述

mapper 请求路由实现

收到客户端请求后，容器根据请求 URL 的上下文名称匹配 Web 应用程序，然后根据去除上下文路径和路径参数的路径，按以下规则顺序匹配，并且只使用第一个匹配的 Servlet，后续不再尝试匹配：

  • 精确匹配，查找一个与请求路径完全匹配的 Servlet
  • 前缀路径匹配，递归的尝试匹配最长路径前缀的 Servlet，通过使用 “/” 作为路径分隔符，在路径树上一次一个目录的匹配，选择路径最长的
  • 扩展名匹配，如果 URL 最后一部分包含扩展名，如 .jsp，则尝试匹配处理此扩展名请求的 Servlet

如果前三个规则没有匹配成功，那么容器要为请求提供一个默认 Servlet，容器在匹配时区分大小写。

举例：
在这里插入图片描述

实现请求映射的一般方法是，首先构建一个路由表，然后按照规范进行匹配，最后返回匹配结果。Tomcat 就是如此，与请求映射相关的类有三个，分别是：

  • Mapper: 存储请求路由表并执行匹配
  • MapperListener: 查询所有的 Host、Context、Wrapper 构建路由表
  • MappingData: 请求映射结果

在这里插入图片描述

启动时解析过程

在这里插入图片描述

双亲委派模型

双亲委派模型

TOMCAT类加载器

Tomcat的自定义类加载器，WebAppClassLoader打破了双亲委托机制：

 public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {

        synchronized (JreCompat.isGraalAvailable() ? this : getClassLoadingLock(name)) {
            if (log.isDebugEnabled()) {
                log.debug("loadClass(" + name + ", " + resolve + ")");
            }
            Class<?> clazz = null;

            // Log access to stopped class loader
            checkStateForClassLoading(name);

            // (0) Check our previously loaded local class cache 
            // 先在本地cache查找该类是否已经加载过
            clazz = findLoadedClass0(name);
            if (clazz != null) {
                if (log.isDebugEnabled()) {
                    log.debug("  Returning class from cache");
                }
                if (resolve) {
                    resolveClass(clazz);
                }
                return clazz;
            }

            // (0.1) Check our previously loaded class cache
            clazz = JreCompat.isGraalAvailable() ? null : findLoadedClass(name);
            if (clazz != null) {
                if (log.isDebugEnabled()) {
                    log.debug("  Returning class from cache");
                }
                if (resolve) {
                    resolveClass(clazz);
                }
                return clazz;
            }

            // (0.2) Try loading the class with the bootstrap class loader, to prevent
            //       the webapp from overriding Java SE classes. This implements
            //       SRV.10.7.2
            String resourceName = binaryNameToPath(name, false);

            ClassLoader javaseLoader = getJavaseClassLoader();
            boolean tryLoadingFromJavaseLoader;
            try {
                // Use getResource as it won't trigger an expensive
                // ClassNotFoundException if the resource is not available from
                // the Java SE class loader. However (see
                // https://bz.apache.org/bugzilla/show_bug.cgi?id=58125 for
                // details) when running under a security manager in rare cases
                // this call may trigger a ClassCircularityError.
                // See https://bz.apache.org/bugzilla/show_bug.cgi?id=61424 for
                // details of how this may trigger a StackOverflowError
                // Given these reported errors, catch Throwable to ensure any
                // other edge cases are also caught
                URL url;
                if (securityManager != null) {
                    PrivilegedAction<URL> dp = new PrivilegedJavaseGetResource(resourceName);
                    url = AccessController.doPrivileged(dp);
                } else {
                    url = javaseLoader.getResource(resourceName);
                }
                tryLoadingFromJavaseLoader = (url != null);
            } catch (Throwable t) {
                // Swallow all exceptions apart from those that must be re-thrown
                ExceptionUtils.handleThrowable(t);
                // The getResource() trick won't work for this class. We have to
                // try loading it directly and accept that we might get a
                // ClassNotFoundException.
                tryLoadingFromJavaseLoader = true;
            }

            if (tryLoadingFromJavaseLoader) {
                try {
                    clazz = javaseLoader.loadClass(name);
                    if (clazz != null) {
                        if (resolve) {
                            resolveClass(clazz);
                        }
                        return clazz;
                    }
                } catch (ClassNotFoundException e) {
                    // Ignore
                }
            }

            // (0.5) Permission to access this class when using a SecurityManager
            if (securityManager != null) {
                int i = name.lastIndexOf('.');
                if (i >= 0) {
                    try {
                        securityManager.checkPackageAccess(name.substring(0,i));
                    } catch (SecurityException se) {
                        String error = sm.getString("webappClassLoader.restrictedPackage", name);
                        log.info(error, se);
                        throw new ClassNotFoundException(error, se);
                    }
                }
            }

            boolean delegateLoad = delegate || filter(name, true);

            // (1) Delegate to our parent if requested
            if (delegateLoad) {
                if (log.isDebugEnabled()) {
                    log.debug("  Delegating to parent classloader1 " + parent);
                }
                try {
                    clazz = Class.forName(name, false, parent);
                    if (clazz != null) {
                        if (log.isDebugEnabled()) {
                            log.debug("  Loading class from parent");
                        }
                        if (resolve) {
                            resolveClass(clazz);
                        }
                        return clazz;
                    }
                } catch (ClassNotFoundException e) {
                    // Ignore
                }
            }

            // (2) Search local repositories
            if (log.isDebugEnabled()) {
                log.debug("  Searching local repositories");
            }
            try {
                clazz = findClass(name);
                if (clazz != null) {
                    if (log.isDebugEnabled()) {
                        log.debug("  Loading class from local repository");
                    }
                    if (resolve) {
                        resolveClass(clazz);
                    }
                    return clazz;
                }
            } catch (ClassNotFoundException e) {
                // Ignore
            }

            // (3) Delegate to parent unconditionally
            if (!delegateLoad) {
                if (log.isDebugEnabled()) {
                    log.debug("  Delegating to parent classloader at end: " + parent);
                }
                try {
                    clazz = Class.forName(name, false, parent);
                    if (clazz != null) {
                        if (log.isDebugEnabled()) {
                            log.debug("  Loading class from parent");
                        }
                        if (resolve) {
                            resolveClass(clazz);
                        }
                        return clazz;
                    }
                } catch (ClassNotFoundException e) {
                    // Ignore
                }
            }
        }

        throw new ClassNotFoundException(name);
    }
  • 0先在本地cache查找该类是否已经加载过
  • 0.1 查找该类是否已经加载过
  • 0.2 尝试使用bootstrap class loader加载

为防止Web应用自己的类覆盖JRE的核心类
因为Tomcat需打破双亲委托，假如Web应用里自定义了一个叫Object的类，若先加载该Object类，就会覆盖JRE的Object类，所以Tomcat类加载器优先尝试委托给BootstrapClassLoader去加载，BootstrapClassLoader发现自己已经加载了Object类，直接返回给Tomcat的类加载器，这样Tomcat的类加载器就不会去加载Web应用下的Object类了，避免覆盖JRE核心类

  • 0.5 安全管理器权限判断
  • 1 过滤排除一些指定的类名，这些类委托父类先加载
  • 2 尝试在本地资源下搜索class并加载
  • 3 尝试用系统类加载器(Class.forName的默认加载器就是系统类加载器，也就是AppClassLoader)来加载

Tomcat 类加载器打破了双亲委托，没有一上来就直接委托给父加载器，为避免本地目录类覆盖JRE核心类先使用了BootstrapClassLoader加载，之后先在本地目录搜索并加载

Tomcat源码分析--启动
黄智霖的博客
03-21 1万+
首先找到catalina.sh中的启动脚本： eval $_NOHUP "\"$_RUNJAVA\"" "\"$CATALINA_LOGGING_CONFIG\"" $LOGGING_MANAGER "$JAVA_OPTS" "$CATALINA_OPTS" \ -D$ENDORSED_PROP="\"$JAVA_ENDORSED_DIRS\"" \ -classpath "\"$CLASSPATH\"" \ -Dcatalina.base="\"$CATALINA_
Tomcat源码分析（一）------ 架构
热门推荐
走向架构师之路
12-14 10万+
废话少说，拉代码，导入eclipse开干，具体步骤可以参考http://hi.baidu.com/hateeyes/blog/item/7f44942a20ad8f9d023bf66d.html下面谈谈我对Tomcat架构的理解总体架构：面向组件架构基于JMX事件侦听1）面向组件架构tomcat代码看似很庞大，但从结构上看却很清晰和简单，它主要由一堆组件组成
Tomcat源码解析（10）
lvhao2813的博客
09-01 262
StandardContext类    Context实例表示一个web应用程序。包含一个或者多个Wrapper实例，每个wrapper都代表一个Servlet。    StandardContext是Context的标准实现，今天说一下工作机制。    StandardContext的配置   创建实例之后，必须调用start()方法，为引入的每个HTTP请求提供服务。可能由于某种
Tomcat启动过程源码解读
八行书
03-07 520
根据Tomcat源码来看一下Tomcat启动过程都做了什么部分代码为主要流程代码，删去了try-catch以及一些校验逻辑，方便理解主流程先来一张启动过程时序图，了解一下启动顺序Tomcat启动的入口类：org.apache.catalina.startup.Bootstrap#mainmain方法是整个tomcat启动时的入口。在main方法中，使用bootstrap.init()来初始化类加载...
TOMCAT源码分析及启动过程
如是所来的专栏
09-11 5538
前言：   本文是我阅读了TOMCAT源码后的一些心得。 主要是讲解TOMCAT的系统框架， 以及启动流程。若有错漏之处，敬请批评指教！建议：   毕竟TOMCAT的框架还是比较复杂的， 单是从文字上理解， 是不那么容易掌握TOMCAT的框架的。 所以得实践、实践、再实践。 建议下载一份TOMCAT的源码， 调试通过， 然后单步跟踪其启动过程。 如果有不明白的地方， 再来查阅本文， 看是否能得到帮
Tomcat源码分析(一)--服务启动
海海人生
07-05 560
  对Tomcat感兴趣是由于《深入理解Tomcat》这本书，之前仅仅是使用到了Tomcat，这本书却让我对Tomcat的实现理解的更加透彻了，在这里希望记录一些自己对Tomcat的理解。由于这本书是基于tomcat4的，所以我的文章也是基于tomcat4的，但是tomcat的核心思想应该是没有变的，最主要的两个组件还是连接器和容器。主要为了学习，就不管是新版本还是旧版本了。 为了...
Apache Tomcat 10.1.0-M8 最新版本发布
资源摘要信息:"Apache Tomcat 10.1.0-M8 是一个开源的Servlet容器，它用于执行Java Servlet和JSP（JavaServer Pages）规范的应用。Tomcat是Apache软件基金会的一个子项目，以其轻量级、高性能和可靠的特性而闻名。...
apache-tomcat-10.1.0-M8.tar.gz
01-20
这个特定的压缩包文件“apache-tomcat-10.1.0-M8.tar.gz”代表的是Apache Tomcat的第10个主要版本的预发布版M8。在Java Web开发中，Tomcat扮演着至关重要的角色，因为它是一个轻量级的Web服务器和应用服务器，具有...
GCC10.1.0源码包及依赖安装教程
根据描述信息，此资源包含了GCC 10.1.0的源码包以及编译GCC所需的依赖包的压缩文件列表。依赖包包括GMP（GNU多精度算术库）、MPFR（GNU多精度浮点复数运算库）和MPC（GNU多精度复数运算库），这些都是GCC正常工作所...
ASP智睿企业视频版网站系统v10.1.0源码解析
资源摘要信息: "ASP智睿企业视频版...由于缺少具体的文件列表和文件内容，无法提供更深入的分析，但可以肯定的是，该系统是一个现成的解决方案，能够帮助企业用户快速建立在线视频平台，满足企业级视频内容管理的需求。
Jspxcms源码包 v10.1.0
01-12
为您提供Jspxcms源码包下载，Jspxcms是基于Java、JSP技术开发的国产开源CMS，是制作、维护网站的利器。国内CMS主要以PHP技术为主，基于Java、Jsp的CMS数量不多，功能和易用性也有一定差距。Jspxcms致力于做最好的...
Tomcat 10 软件及其源码
最新发布
04-30
版本：apache-tomcat-10.1.23 Tomcat 10 是 Apache Tomcat 的一个版本，它引入了一些新的功能和改进。以下是一些关键的新增功能： 1. JDK 11 支持：Tomcat 10 支持 JDK 11，这意味着它可以用于 JDK 11 的项目中。 2. HTTP/2：Tomcat 10 支持 HTTP/2，这是一个重大的性能提升，因为它可以更好地利用多路复用特性。 3. Jakarta EE 9 支持：Tomcat 10 支持 Jakarta EE 9 规范。 4. WebSocket 1.1 支持：Tomcat 10 支持 WebSocket 1.1 规范。 5. 改进的安全性：包括对 OAuth 2.0 的支持和其他安全相关的改进。 6. 模块化设计：Tomcat 10 采用了模块化设计，这使得它可以更容易地进行定制和配置。 7. 异步 IO：Tomcat 10 使用了新的异步 IO 支持，这提高了性能和资源效率。 8. 改进的 Metrics 支持：提供了更好的方式来监控和分析应用性能。
tomcat10 windows安装版.zip
05-15
tomcat10最新windows安装版本，Apache官网直连下载，优快云内网加速，快速下载，纵享丝滑
《Tomcat源码解析》Tomcat启动过程
Turbo码先生
03-27 1269
《史上最全Tomcat源码解析》Tomcat启动过程 文章目录《史上最全Tomcat源码解析》Tomcat启动过程前言一、启动过程二、使用步骤1.引入库2.读入数据总结 前言 在上一章对Tomcat的架构进行了分析，这一章，我们来看一下Tomcat的启动过程 一、启动过程 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns
Tomcat 源码分析 (Tomcat的启动过程) (三)
959
07-22 468
启动过程
Tomcat源码解析：5、Tomcat启动
dk2077的博客
01-02 351
Bootstrap org.apache.catalina.startup.Bootstrap类是Tomcat的入口，当我们想在IDE中运行Tomcat进行调试，可以找到这个类直接运行main方法。 我们看下Bootstrap的main方法 public static void main(String args[]) { if (daemon == null) { ...
拆解Tomcat10: (二) 在Idea中调试最新的Tomcat10源码
2i3i.com
11-28 6324
如何下载并在Idea中编译及调试最新版的Tomcat10？
tomcat源码分析之系统框架与启动流程
xiecg2000的博客
05-05 170
前言：　　本文是我阅读了TOMCAT源码后的一些心得。 主要是讲解TOMCAT的系统框架， 以及启动流程。若有错漏之处，敬请批评指教！　　建议：　　毕竟TOMCAT的框架还是比较复杂的， 单是从文字上理解， 是不那么容易掌握TOMCAT的框架的。 所以得实践、实践、再实践。 建议下载一份TOMCAT的源码， 调试通过， 然后单步跟踪其启动过程。 如果有不明白的地方， 再来查阅本文， 看是否能得到帮...
TOMCAT源码分析(启动框架)
meiyoudao
09-11 155
转载：http://edu.codepub.com/2010/0518/22773.php TOMCAT源码分析(启动框架) 前言： 本文是我阅读了TOMCAT源码后的一些心得。 主要是讲解TOMCAT的系统框架， 以及启动流程。若有错漏之处，敬请批评指教！ 建议： 毕竟TOMCAT的框架还是比较复杂的， 单是从文字上理解， 是不那么容易掌握TOMCAT的框架的。 所以得...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值