`
uule
  • 浏览: 6348670 次
  • 性别: Icon_minigender_1
  • 来自: 一片神奇的土地
社区版块
存档分类
最新评论

StandardService分析-tomcat6.x源码阅读

 
阅读更多

来源:https://my.oschina.net/douglas/blog/161607

 

<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 HTTP/1.1 Connector on port 8080
    -->
    <Connector connectionTimeout="20000" port="8090" protocol="HTTP/1.1" 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 HTTP/1.1 Connector on port 8443
         This connector uses the JSSE configuration, when using APR, the
         connector should be using the OpenSSL style configuration
         described in the APR documentation -->
    <!--
    <Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true"
               maxThreads="150" 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 defaultHost="localhost" name="Catalina">

      <!--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 appBase="webapps" autoDeploy="true" name="localhost" unpackWARs="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" pattern="%h %l %u %t &quot;%r&quot; %s %b" prefix="localhost_access_log." suffix=".txt"/>

         </Host>
    </Engine>
  </Service>

 

StandardService是什么

StandardService标准实现Service接口,在tomcat的结构图中,Service位于Server的内部,类似公司的经理职务。从字面上可以看出,Service是一种服务,一种网络协议来对外提供服务的组件。从结构图上看出Service内部管理一个或者多个连接器Connector和一个容器Container(Engine),

连接器负责接收和响应网络访问

容器(Engine)负责处理网络访问,将网络请求转到Servlet中处理。

一句话,Service是通过连接器接收网络请求,并通过调度Servlet处理请求寄居在Server提供服务的组件。注意,一个Server中可以有多少Service。

Lifecycle
与Server类似,通过Lifecycle可以监控Service组件的状态和在不同生命周期阶段修改Service组件的状态。

MBeanRegistration
实现该接口的目的是可以通过JMX来监控组件。

LifecycleSupport
是Service的属性,作用与Server中的一样,负责管理和维护注册在Service上面并实现LifecycleListener接口的监听类,监听跟生命周期有关的事件。

PropertyChangeSupport
是Service的属性,作用与Server中的一样,负责管理和维护注册在Service上面并实现PropertyChangeListener接口的监听类,监听跟Service属性更新有关的事件。

Server
是Service的属性,Service寄居的Server,负责管理Service,不同Service共享Server的数据。

Connector
StandardService的连接器,一个Service中可以有多个连接器,所以在StandardService中有一个Connector数组。Connector监听网络端口,接收网络请求,将请求转到容器中处理,具体是启动一个ServerSocket监听某个网络端口(默认port:8080),当请求到来时接收请求创建Socket对象,将对象分配给一个线程处理。在tomcat的配置文件server.xml中有如下配置:

<!-- 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 HTTP/1.1 Connector on port 8080 -->
        <!-- 配置连接器,监听8080端口,协议类型是HTTP/1.1,连接timeout时间:20000,
                        当ssl传输请求后重定向的端口,默认协议处理器使用:org.apache.coyote.http11.Http11Protocol-->
        <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 HTTP/1.1 Connector on port 8443 This connector uses the 
            JSSE configuration, when using APR, the connector should be using the OpenSSL 
            style configuration described in the APR documentation -->
        <!-- <Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true" maxThreads="150" 
            scheme="https" secure="true" clientAuth="false" sslProtocol="TLS" /> -->

        <!-- Define an AJP 1.3 Connector on port 8009 -->
        <!-- service之间请求的监听 -->
        <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />

 

从server.xml得知tomcat默认支持的协议是HTTP/1.1,监听8080端口,连接timeout:20000,协议处理器类是org.apache.coyote.http11.Http11Protocol(看Connector源码),还启动了一个负责处理Service直接的请求的连接器AJP/1.3。Connector的具体内容在Connector小节分析。tomcat通过Digester库将Service的xml配置的信息生成对象,并设置属性和父子关系。

Container
StandardService的属性,角色是StandardService的容器,一般是Engine容器,作用是为连接器转来的请求选择路由转给特定Servlet处理,维护和管理容器中子容器,同时为子容器提供数据共享功能。在StandardService中添加容器,需要以下几步完成:

  • 保留原来的Container,用于属性更新事件通知
  • 判断原来Container类型,若为Engine,设置Engine的Service属性为null
  • 更新container值,判断新Container类型,若为Engine,设置Engine的Service属性为为当前Service对象引用
  • 判断Service是否已经启动,若启动,调用Container..start()启动容器,使之工作,提供服务。
  • 更新连接器管理的Container
  • 停止原来的Container
  • 触发Service属性变更事件通知

经过上面几步完成了为Service设置Container的任务

/**
     * Set the <code>Container</code> that handles requests for all
     * <code>Connectors</code> associated with this Service.
     *  设置容器能否处理请求的所有连接器关联这个服务
     * @param container
     *            The new Container
     */
    public void setContainer(Container container) {

        //属性事件监听使用
        Container oldContainer = this.container;
        if ((oldContainer != null) && (oldContainer instanceof Engine))
            //移除旧容器的服务所属
            ((Engine) oldContainer).setService(null);
        this.container = container;
        if ((this.container != null) && (this.container instanceof Engine))
            //设置新容器的服务所属
            ((Engine) this.container).setService(this);
        if (started && (this.container != null)&& (this.container instanceof Lifecycle)) {//判断服务是否已经启动
            try {
                ((Lifecycle) this.container).start();//启动新容器
            } catch (LifecycleException e) {
                ;
            }
        }
        synchronized (connectors) {//同步
            for (int i = 0; i < connectors.length; i++)
                connectors[i].setContainer(this.container);//更新连接器所属容器
        }
        if (started && (oldContainer != null)
                && (oldContainer instanceof Lifecycle)) {
            try {
                ((Lifecycle) oldContainer).stop();//停止旧容器
            } catch (LifecycleException e) {
                ;
            }
        }

        // Report this property change to interested listeners
        //通知属性监听事件
        support.firePropertyChange("container", oldContainer, this.container);

    }

 

Executor
线程执行器,在StandardService有一个Executor数组,负责执行分配到Executor上的线程,从我的理解角度来看,他就是线程池。在StandardService中,负责执行连接器接收请求并分配到Executor上的线程。Executor数组可以为null,当为null时表示不使用线程池,实时生成线程运行器。tomcat中对于Executor的配置如下:

 <!--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"/> -->

 

从配置文件看出,tomcat默认不是使用线程池。为啥呢?开启线程池之后的性能是否有所提升,有时间验证一下。

init()
StandardService调用init()方法来初始化,在init()方法内部调用的是initialize(),StandardService启动之前需要先对StandardService初始化,在initialize()中主要完成以下几个步骤

  • 判断是否已经初始化
  • 设置已经初始化标记,initialized = true
  • 容器和线程池注册到JMX,通过管理页面监控和操作
  • 关联Server
  • 初始化连接器
  • /**
         * Invoke a pre-startup initialization. This is used to allow connectors to
         * bind to restricted ports under Unix operating environments.
         * 预启动初始化,在unix操作环境下面通常允许连接器并定端口
         */
        public void initialize() throws LifecycleException {
            // Service shouldn't be used with embeded, so it doesn't matter
            //服务不能被用于内嵌到其他程序中,所以没有关系
            if (initialized) {//是否已经初始化
                if (log.isInfoEnabled())
                    log.info(sm.getString("standardService.initialize.initialized"));
                return;
            }
            initialized = true;//标记初始化
    
            if (oname == null) {
                try {
                    // Hack - Server should be deprecated...
                    //获取容器引用
                    Container engine = this.getContainer();
                    domain = engine.getName();
                    oname = new ObjectName(domain + ":type=Service,serviceName="
                            + name);
                    this.controller = oname;
                    //注册容器
                    Registry.getRegistry(null, null).registerComponent(this, oname,
                            null);
    
                    //注册执行器
                    Executor[] executors = findExecutors();
                    for (int i = 0; i < executors.length; i++) {
                        ObjectName executorObjectName = new ObjectName(domain
                                + ":type=Executor,name=" + executors[i].getName());
                        Registry.getRegistry(null, null).registerComponent(
                                executors[i], executorObjectName, null);
                    }
    
                } catch (Exception e) {
                    log.error(
                            sm.getString("standardService.register.failed", domain),
                            e);
                }
    
            }
            if (server == null) {
                // Register with the server
                // HACK: ServerFactory should be removed...
    
                //添加服务
                ServerFactory.getServer().addService(this);
            }
    
            // Initialize our defined Connectors
            synchronized (connectors) {//同步连接器
                for (int i = 0; i < connectors.length; i++) {
                    try {
                        connectors[i].initialize();//初始化连接器
                    } catch (Exception e) {
                        String message = sm.getString(
                                "standardService.connector.initFailed",
                                connectors[i]);
                        log.error(message, e);
    
                        if (Boolean
                                .getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE"))
                            throw new LifecycleException(message);
                    }
                }
            }
        }
     

经过上面几个步骤后,StandardService完成初始化。

start()
StandardService完成初始化后,完成准备工作,调用start()方法启动Service,正常情况下,start()方法有StandardServer来触发调用。StandardService在启动过程过程中要完成下列几个步骤:

  • 判断是否已经启动
  • 判断是否初始化,若未初始化,调用initialize()方法初始化Service
  • 触发BEFORE_START_EVENT,START_EVENT事件通知,设置启动标记
  • 启动Container,一般是Engine,激活请求处理逻辑。
  • 启动连接池执行器,赋予运行请求处理线程能力
  • 启动连接器,监听网络端口
  • 触发AFTER_START_EVENT事件通知
  • /**
         * Prepare for the beginning of active use of the public methods of this
         * component. This method should be called before any of the public methods
         * of this component are utilized. It should also send a LifecycleEvent of
         * type START_EVENT to any registered listeners.
         * 准备开始这个组件的公有方法,这个方法调用应该在这个组件被调用在之前,同时发送START_EVENT
         * 生命周期事件监听给所有已经登记的监听事件
         * 
         * @exception LifecycleException
         *                if this component detects a fatal error that prevents this
         *                component from being used
         */
        public void start() throws LifecycleException {
    
            // Validate and update our current component state
            if (started) {
                if (log.isInfoEnabled()) {
                    log.info(sm.getString("standardService.start.started"));
                }
                return;
            }
    
            if (!initialized){//判断是否初始化
                init();//初始化
            }
    
    
            // Notify our interested LifecycleListeners
            //开始启动之前事件监听
            lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
            if (log.isInfoEnabled())
                log.info(sm.getString("standardService.start.name", this.name));
            //启动事件监听
            lifecycle.fireLifecycleEvent(START_EVENT, null);
            started = true;
    
            // Start our defined Container first
            if (container != null) {
                synchronized (container) {//同步
                    if (container instanceof Lifecycle) {
                        ((Lifecycle) container).start();//启动容器
                    }
                }
            }
    
            synchronized (executors) {//同步执行器
                for (int i = 0; i < executors.size(); i++) {
                    executors.get(i).start();//启动执行器
                }
            }
    
            // Start our defined Connectors second
            synchronized (connectors) {//同步连接器
                for (int i = 0; i < connectors.length; i++) {
                    try {
                        ((Lifecycle) connectors[i]).start();//启动连接器
                    } catch (Exception e) {
                        log.error(sm.getString(
                                "standardService.connector.startFailed",
                                connectors[i]), e);
                    }
                }
            }
    
            // Notify our interested LifecycleListeners
            //启动之后事件监听通知
            lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
    
        }
     

Service组件启动顺序,第一步先启动Container,开启请求处理逻辑能力,第二部再启动连接池执行器,开启线程处理请求的能力,第三步再启动连接器,监听网络端口。组件的功能依赖关系决定了组件的启动顺序。

stop()

停止StandardService的方法stop(),需要停止服务时,需要清理tomcat所占用的资源,在stop()方法中需要完成以下几个步骤:

  • 判断是否已经启动
  • 触发BEFORE_STOP_EVENT事件通知
  • 暂停连接器,暂停接收新请求
  • 触发STOP_EVENT事件监听,设置停止运行标记started = false
  • 停止Container,停止处理请求逻辑,一般是Engine容器
  • 停止连接器,停止监听网络端口
  • 停止连接池执行器
  • 撤销JMX注册
  • 触发AFTER_STOP_EVENT事件通知
  • /**
         * Gracefully terminate the active use of the public methods of this
         * component. This method should be the last one called on a given instance
         * of this component. It should also send a LifecycleEvent of type
         * STOP_EVENT to any registered listeners.
         * 停止服务的公有方法,应该在最后被调用,同时发送停止生命周期事件通知。
         * 
         * @exception LifecycleException
         *                if this component detects a fatal error that needs to be
         *                reported
         */
        public void stop() throws LifecycleException {
    
            // Validate and update our current component state
            if (!started) {
                return;
            }
    
            // Notify our interested LifecycleListeners
            //开始停止服务事件通知
            lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);
    
            // Stop our defined Connectors first
            //首先停止连接器
            synchronized (connectors) {//同步连接器
                for (int i = 0; i < connectors.length; i++) {
                    try {
                        connectors[i].pause();//为何是pause(首先停止接收请求,给予时间缓冲处理已经接收但未完成处理的请求)
                    } catch (Exception e) {
                        log.error(sm.getString(
                                "standardService.connector.pauseFailed",
                                connectors[i]), e);
                    }
                }
            }
    
            // Heuristic: Sleep for a while to ensure pause of the connector
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // Ignore
            }
    
            //停止服务事件通知
            lifecycle.fireLifecycleEvent(STOP_EVENT, null);
            if (log.isInfoEnabled()){
                log.info(sm.getString("standardService.stop.name", this.name));
            }
            started = false;//标记服务停止
    
            // Stop our defined Container second
            //停止容器
            if (container != null) {
                synchronized (container) {//同步
                    if (container instanceof Lifecycle) {
                        ((Lifecycle) container).stop();//停止
                    }
                }
            }
            // FIXME pero -- Why container stop first? KeepAlive connetions can send
            // request!
            //为何先停止容器,确保KeeoAlive连接器能够发送请求
            // Stop our defined Connectors first
            //停止连接器
            synchronized (connectors) {//同步连接器队列
                for (int i = 0; i < connectors.length; i++) {
                    try {
                        ((Lifecycle) connectors[i]).stop();//停止连接器
                    } catch (Exception e) {
                        log.error(sm.getString(
                                "standardService.connector.stopFailed",
                                connectors[i]), e);
                    }
                }
            }
    
            //停止执行器
            synchronized (executors) {
                for (int i = 0; i < executors.size(); i++) {
                    executors.get(i).stop();
                }
            }
    
            if (oname == controller) {
                // we registered ourself on init().
                // That should be the typical case - this object is just for
                // backward compat, nobody should bother to load it explicitely
                //开除注册
                Registry.getRegistry(null, null).unregisterComponent(oname);
                Executor[] executors = findExecutors();
                for (int i = 0; i < executors.length; i++) {
                    try {
                        ObjectName executorObjectName = new ObjectName(domain
                                + ":type=Executor,name=" + executors[i].getName());
                        //移除执行器
                        Registry.getRegistry(null, null).unregisterComponent(
                                executorObjectName);
                    } catch (Exception e) {
                        // Ignore (invalid ON, which cannot happen)
                    }
                }
            }
    
            // Notify our interested LifecycleListeners
            //完成停止服务事件通知
            lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
    
        }
     

从代码中可以看出,Service组件的停止顺序与启动顺序差不多刚好相反,首先连机器暂停接收新请求后,缓冲1s,处理已经接收到的请求,然后停止Container,紧接着停止连接器,最后停止连接池执行器。

destroy()
StandardService的销毁方法非常简单,直接调用stop()方法。

StandardService作为一个服务存在,寄居在Server中,维护和管理连接器和Container,实现了监听网络端口,并将网络请求转到Container中处理完成响应请求的任务。StandardService共享Server中的资源,同时也共享给在Service内部的组件,StandardService完成的功能很简练:寄居Server,启动连接器,启动Container,至于如何监听网络请求和处理网络请求则交给连接器和Container处理。

分享到:
评论

相关推荐

    apache-tomcat-9.0.0.M1-src

    【Apache Tomcat 9.0.0.M1 源码分析】 Apache Tomcat是一款开源的、免费的Java Servlet容器,它实现了Java EE Web应用程序的Servlet和JSP规范。源码包“apache-tomcat-9.0.0.M1-src”提供了Tomcat的核心源代码,供...

    apache-tomcat-8.5.100-src Tomcat源码解析

    源码阅读过程中,你可以关注类之间的依赖关系,了解它们如何协作处理请求,以及如何通过配置文件来调整Tomcat的行为。此外,学习Tomcat的线程模型、错误处理机制以及安全性相关的实现,都能让你更深入地理解其工作...

    apache-tomcat-6.0.18源码

    源码分析: 1. **目录结构**:解压后的源码文件夹通常包含`bin`、`conf`、`lib`、`logs`、`webapps`、`work`等目录。`bin`存放启动和停止服务器的脚本,`conf`存储配置文件,`lib`包含运行Tomcat所需的JAR文件,`...

    tomcat7源码环境部署

    这里我们讨论的主题是"Tomcat7源码环境部署",这涉及到对Tomcat服务器的深入理解,包括其内部工作原理、源码分析以及如何在本地环境中构建和部署。下面将详细介绍相关知识点。 首先,源码部署意味着你需要从Apache ...

    apache-tomcat-7.0.57-src可导入Myeclipse

    3. **定位源代码**:在“Select root directory”中,浏览并选择你刚刚解压的Tomcat源码目录。 4. **配置构建路径**:在导入的项目中,你需要配置Java构建路径,确保所有的依赖库都正确引用。这可能包括添加JDK和...

    Tomcat7 核心包 catalina包源码

    《深入解析Tomcat7 Catalina核心包源码》 Tomcat作为开源的Java Servlet容器,是Web服务器领域的重要角色,其高效、轻量级的特性深受开发者喜爱。在Tomcat7版本中,Catalina是核心组件之一,负责处理HTTP请求和响应...

    tomcat 6 源码

    通过研究Tomcat源码,开发者可以学习到如何构建一个高性能的Servlet容器,掌握Java Web应用的核心运行机制,这对于提升Java EE开发能力大有裨益。同时,如果你遇到Tomcat的使用问题或者想要进行定制化开发,源码分析...

    tomcat架构的源码分析

    ### Tomcat架构的源码分析 #### 一、Tomcat的架构概述 Tomcat作为一款广泛使用的开源Java Servlet容器,其内部架构设计简洁而高效。本文档将对Tomcat的架构进行详细介绍,并从源码层面深入分析其核心组成部分。...

    tomcat6源码

    《深入剖析Tomcat6源码》 ...通过对Tomcat6源码的分析,开发者不仅可以提升对Web服务器内部运作的理解,还能学习到如何优化性能、调试问题以及定制化开发。这将对Java Web开发和系统架构设计有着深远的影响。

    02-Tomcat源码解读1

    总的来说,Tomcat源码解读需要把握住Server和Service这两个核心组件,理解它们如何通过Connector与Engine协同工作,以及生命周期管理和启动流程的设计。同时,要关注Container的层次结构以及与配置文件的交互,这将...

    我的tomcat7源码手撕过程

    ### Tomcat7源码手撕过程详解 #### Tomcat初始化流程分析 Tomcat是一个流行的Java Servlet容器,用于部署和运行Web应用程序。理解Tomcat的工作原理对于优化应用性能、解决部署问题至关重要。以下是对Tomcat7启动...

    Tomcat服务器源码

    Tomcat源码主要由以下几个关键组件构成: 1. **Catalina**:这是Tomcat的核心组件,负责处理Servlet容器的主要功能,包括Servlet和JSP的加载、调度和执行。Catalina的核心类是`org.apache.catalina.core....

    学习tomcat源码+英文《How Tomcat Work》和每一章的相关项目+tomcat6源码依赖jar

    在深入探讨Tomcat源码之前,我们先了解一下Tomcat是什么。Tomcat是一款开源的Java Servlet容器,由Apache软件基金会开发,它实现了Java EE中的Web应用服务器部分,特别是Servlet和JavaServer Pages (JSP)规范。《How...

    tomcat源码分析

    ### Tomcat源码分析 #### 一、概述 Apache Tomcat是Java开发人员最常用的Web服务器之一,它不仅能够作为独立的应用程序运行Servlet和JavaServer Pages(JSP),还可以作为一个内嵌的容器来运行Web应用。Tomcat的...

    tomcat8.0源码

    【标题】"Tomcat 8.0源码分析" 【正文】 Tomcat 8.0是Apache软件基金会的开源项目,是一个广泛使用的Java Servlet容器,实现了Java Servlet和JavaServer Pages(JSP)规范,用于部署和运行Web应用程序。源码分析...

    Tomcat源码研究

    《Tomcat源码研究》 Tomcat,全称Apache Tomcat,是一款开源的Java Servlet容器,它是Apache软件基金会Jakarta项目的重要组成部分。Tomcat作为轻量级应用服务器,广泛应用于Web应用程序的部署和运行,其核心是基于...

    Tomcat7启动分析(三)Digester的使用

    在Java Web开发中,Tomcat是一个广泛使用的开源应用服务器,主要负责运行Servlet和JSP。在Tomcat7的启动过程中,涉及到很多内部组件的初始化,其中`Digester`是一个重要的工具,用于解析XML配置文件,将XML结构映射...

    tomcat6.0.39源代码

    9. **性能优化**:Tomcat源码中包含了很多可调整的参数和设置,如线程池大小、缓冲区大小、超时时间等,这些都是性能调优的关键。 10. **集群支持**:如果需要构建高可用的Tomcat集群,`Cluster`模块的源码提供了...

Global site tag (gtag.js) - Google Analytics