tomcat配置文件web.xml与server.xml解析--重要

Web.xml里主要的内容：

 

关于servlet的定义：

<servlet>

        <servlet-name>default</servlet-name>

        <servlet-class>

          org.apache.catalina.servlets.DefaultServlet

        </servlet-class>

        <init-param>

            <param-name>debug</param-name>

            <param-value>0</param-value>

        </init-param>

        <init-param>

            <param-name>listings</param-name>

            <param-value>true</param-value>

        </init-param>

        <load-on-startup>1</load-on-startup>

</servlet>

。。。。。。

关于servlet-mapping的定义：

<servlet-mapping>

    <servlet-name>default</servlet-name>

    <url-pattern>/</url-pattern>

</servlet-mapping>

 

<servlet-mapping>

        <servlet-name>jsp</servlet-name>

        <url-pattern>*.jsp</url-pattern>

    </servlet-mapping>

 

    <servlet-mapping>

        <servlet-name>jsp</servlet-name>

        <url-pattern>*.jspx</url-pattern>

    </servlet-mapping>

 

关于session-config的定义：

<session-config>

        <session-timeout>30</session-timeout>

    </session-config>

 

关于mime-mapping的定义：

<mime-mapping>

        <extension>abs</extension>

        <mime-type>audio/x-mpeg</mime-type>

    </mime-mapping>

 

最后是关于welcom-file-list的定义：

       <welcome-file-list>

        <welcome-file>index.html</welcome-file>

        <welcome-file>index.htm</welcome-file>

        <welcome-file>index.jsp</welcome-file>

</welcome-file-list>

 

可能还有事件监听器，过滤器

事件监听器：

事件监听器和servlet的过滤器类似，都是在web程序被部署到web服务器时生成并被初始化的。

几类监听器的作用：

ServletContext监听器接口可以使web得知整个程序的载入和卸载等运行情况。

HttpSession监听器接口可以使web程序了解程序会话期间的状况并作出响应。

ServletRequest监听器接口可以使web程序控制请求的生命周期。

 

在第一个请求被web容器接受之前实例化并注册好监听器类是必须的。监听器在整个web应用生命周期中都要使用。

web容器对每个监听类只会创建一个实例（单例模式），在第一个请求到来之前实例化并注册。web容器注册监听类的顺序根据他们实现的接口和在部署描述文件中定义的顺序。web应用调用监听实例的顺序按照他们注册的顺序。

对appfuse来说，在web容器根据应用程序部署文件web.xml进行部署的时候，首先完成对listener和filter的实例化和初始化，然后由于

public class StartupListener extends ContextLoaderListener

    implements ServletContextListener {。。。。

StartupListener继承自ServletContextListener，因此在容器对servletContext进行初始化的时候，会调用这个监听。由于在appfuse应用程序的web.xml里有关于spring的配置信息，因此这里就把spring配置好了！！！

 

过滤器：

Filter生命周期

在web工程发布后，在请求使引擎访问一个web资源之前，引擎必须定位Filter列表；引擎必须确保为列表中的每一个Filter建立了一个实例，并调用了他们的init(FilterConfig config)方法。在这过程中可以抛出异常。部署描述文件中定义的所有filter，仅会在引擎中产生一个实例。

当引擎接受一个请求时，引擎就会调用filter列表中第一个filter的doFilter方法，把ServletRequest，ServletResponse和FilterChain作为参数传给它。filter中doFilter方法典型的处理步骤是：

1）检查请求头信息

2）开发者创建一个实现了ServletRequest或HttpServletRequest的类，去包装request对象，以便修改请求的头信息或体数据。

3）开发者创建一个实现了ServletReqponse或HttpServletResponse的类，去包装response对象，以便修改请求的头信息或体数据。

4)filter可以调用链中的下一个实体，下一个实体是另一个filter，如果该filter是列表中最后的一个，则它的下一个实体就是一个目标web资源。如果要调用下一个filter的doFilter方法，把request，和response对象传给FilterChain对象的doFilter方法中就可以了。

Filter chain 的doFilter方法是由引擎提供的，引擎在该方法中会定位filter列表中的下一个filter，调用它的doFilter方法，把传来的request和response对象传给它。

5）在调用chain.doFilter之后，filter可以检测响应的头信息

6）在这些过程中，filter可以抛出异常。当在调用doFilter过程中抛出UnavailableException异常时，引擎重复尝试处理

下面的filter chain的方法，如过时后还没请求到filter chain 就会关闭对filter chain的请求。当filter是列表中最后一个filter时，它的下一个实体是描述配置文件中filter后面的servlet或其它资源。

在引擎删除一个Filter之前，引擎必须调用Filter的destroy方法，来释放资源。

 

Web.xml：都是关于应用程序的。

 

<web-app >

各种<context-param>。。。。

各种<filter>，以及<filter-mapping>。。。。

各种<listener>。。。。

各种<servlet>，以及<servlet-mapping>。。。

<session-config>

<welcome-file-list>

    各种<error-page>。。。。

       <taglib>

       <resource-ref>

       <security-constraint>

       <login-config>

       <security-role>

 

Server.xml里的主要内容：

首先是关于server的定义：

<Server port="8005" shutdown="SHUTDOWN" debug="0">

。。。

关于server的注释：

A "Server" is a singleton element that represents the entire JVM,

     which may contain one or more "Service" instances.  The Server

     listens for a shutdown command on the indicated port.

 

关于listener的定义：

<Listener className="org.apache.catalina.mbeans.ServerLifecycleListener"

            debug="0"/>

  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener"

            debug="0"/>

 

关于globalNamingResources的定义：

<GlobalNamingResources>

 

    <!-- Test entry for demonstration purposes -->

    <Environment name="simpleValue" type="java.lang.Integer" value="30"/>

 

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

    </Resource>

    <ResourceParams name="UserDatabase">

      <parameter>

        <name>factory</name>

        <value>org.apache.catalina.users.MemoryUserDatabaseFactory</value>

      </parameter>

      <parameter>

        <name>pathname</name>

        <value>conf/tomcat-users.xml</value>

      </parameter>

    </ResourceParams>

 

  </GlobalNamingResources>

 

关于service的定义：

<Service name="Catalina">

。。。

              注意connector和engine（container）都是service里的元素。

 

关于connector的定义：

<Connector port="8000"       URIEncoding="gbk"

               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"

               enableLookups="false" redirectPort="8443" acceptCount="100"

               debug="0" connectionTimeout="20000"

               disableUploadTimeout="true" />

关于connector的注释：

A "Connector" represents an endpoint by which requests are received

         and responses are returned.  Each Connector passes requests on to the

         associated "Container" (normally an Engine) for processing.

 

关于engine的定义：

       <Engine name="Catalina" defaultHost="localhost" debug="0">

       。。。

 

关于engine的注释：

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).

 

关于logger的定义：

<Logger className="org.apache.catalina.logger.FileLogger"

              prefix="catalina_log." suffix=".txt"

              timestamp="true"/>

 

关于realm的定义：

<Realm className="org.apache.catalina.realm.UserDatabaseRealm"

                 debug="0" resourceName="UserDatabase"/>

 

关于host的定义：

<Host name="localhost" debug="0" appBase="webapps"

       unpackWARs="true" autoDeploy="true"

       xmlValidation="false" xmlNamespaceAware="false">

 

关于logger的定义：

<Logger className="org.apache.catalina.logger.FileLogger"

                 directory="logs"  prefix="localhost_log." suffix=".txt"

            timestamp="true"/>

关于logger的注释：

Logger shared by all Contexts related to this virtual host.  By

          default (when using FileLogger), log files are created in the "logs"

           directory relative to $CATALINA_HOME.  If you wish, you can specify

           a different directory with the "directory" attribute.  Specify either a

           relative (to $CATALINA_HOME) or absolute path to the desired

           directory.

 

。。。后面还可能有关于context的定义。

 

server<!--[if !supportAnnotations]-->[z1]<!--[endif]--> .xml：都是关于服务器一些特性的。

一个server有一个service，一个service里有多个connector和一个engine，不同的connector除了端口可能不同，协议也可能不同。多个connector对应一个engine。engine代表我们应用程序的容器。一个engine中有一个到多个host，一个host代表我们的一个虚拟主机。host里又有一个到多个context，一个context代表了一个应用程序的虚拟子站点。

 

应用程序里也有web.xml和struts-config.xml，这两个配置文件的内容不同于tomcat自带的配置文件。

 

tomcat应用程序的初始化和运行过程：

在tomcat启动时的工作（初始化）：

由于应用程序是放在webapps目录下面的，在Tomcat启动时，其web容器会自动校验和载入此目录内的web程序，使其可以直接工作。如果程序有错，web服务器会将错误信息输出或存入在logs目录，若错误严重，tomcat可能会停止工作。

 

从上面我们可以看到一个webapp应用程序中，包含的元素有：

Filter，listener，servlet。它们初始化的时机应该是不一样的。

 

Servlet和jsp的生命周期：

从Tomcat处理用户请求，我们可以清晰的看到容器Servlet的生命周期管理过程：

1、Tomcat在启动的时候应该直接加载并实例化webapps下面应用程序的listener和filter，并在相应的时机进行调用。

2、客户发出请求—>Web 服务器转发到Web容器Tomcat；

3、Tomcat主线程对转发来用户的请求做出响应创建两个对象：HttpServletRequest和HttpServletResponse；

4、从请求中的URL中找到正确Servlet，Tomcat为其创建或者分配一个线程，同时把3创建的两个对象传递给该线程；

5、Tomcat调用Servlet的servic()方法，根据请求参数的不同调用doGet()或者doPost()方法；

6、假设是HTTP GET请求，doGet()方法生成静态页面，并组合到响应对象里；

7、Servlet线程结束，Tomcat将响应对象转换为HTTP响应发回给客户，同时删除请求和响应对象。

从该过程中，我们可以理解Servlet的生命周期：Servlet类加载（对应4步）；Servlet实例化（对应3步）；调用init方法（对应4步）；调用service()方法（对应5、6步）；；调用destroy()方法（对应7步）。

从中可以看到servlet和jsp是在请求到来的时候，web容器进行首次对servlet或jsp（转换为servlet）的初始化。而且初始化一次之后，在web容器中就只存在这样一个实例，利用多线程来处理不同用户的请求。

 

Struts-config.xml

<form-beans>

       各种<form-bean>

 

<global-exceptions>

<global-forwards>

              各种<forward>。。。。

<action-mappings>

各种<action>。。。。action里还可能有forward元素，如果有，而且它与global-forwards里的重名，则它会将global里的覆盖。

 

各种</plug-in>

<!--[if !supportAnnotations]-->

<!--[endif]-->