Linuxjava理解服务器学习

[转][笔记] 2. Tomcat系列之服务器的安装与配置以及各

2016-08-01  本文已影响1090人  C86guli

转自陈明乾的博客，可能有一定更新。

转原文声明：
原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。http://freeloda.blog.51cto.com/2033581/1299644

大纲

注，本文的测试的操作系统为 CentOS 6.8 x86_64，软件版本为 jdk-8u101、apache-tomcat-7.0.70。

软件下载地址：

一、前言

在上一篇博文中我们主要讲解的Tomcat的基础知识以及相关的Java知识，对于不怎么清楚的博友可以参考一下：http://freeloda.blog.51cto.com/2033581/1298687。

在这博客中我们主要讲解Tomcat的安装与配置详解。那下面我们就来说一下吧！

二、安装与配置Tomcat

1.查看一下安装文件

[root@tomcat1 ~]# ls -1
apache-tomcat-7.0.70.tar.gz
jdk-8u101-linux-x64.rpm

2.同步一下时间

[root@tomcat java]# ntpdate 202.120.2.101

3.安装JDK

[root@tomcat1 ~]# rpm -ivh jdk-8u101-linux-x64.rpm

4.修改环境变量

注意，CentOS 6.8 预先安装了 OpenJDK:

[root@tomcat1 ~]# /usr/bin/java -version
openjdk version "1.8.0_91"
OpenJDK Runtime Environment (build 1.8.0_91-b14)
OpenJDK 64-Bit Server VM (build 25.91-b14, mixed mode)

要使用我们安装 jdk，应该设置 PATH 环境变量，在搜索命令时，首先查找 $JAVA_HOME/bin 下的路径，设置环境变量如下：

[root@tomcat1 ~]# cat /etc/profile.d/java.sh
export JAVA_HOME=/usr/java/jdk1.8.0_101/
export PATH=$JAVA_HOME/bin:$PATH

使其立即生效：

[root@tomcat1 ~]# source /etc/profile.d/java.sh

5.测试一下

[root@tomcat1 ~]# java -version
java version "1.8.0_101"
Java(TM) SE Runtime Environment (build 1.8.0_101-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.101-b13, mixed mode)

注：好了，到这里我们的jdk就安装成功了。下面我们来安装一下Tomcat！

6.解压并创建链接

[root@tomcat1 ~]# tar -xf apache-tomcat-7.0.70.tar.gz -C /usr/local/
[root@tomcat1 ~]# cd /usr/local/
[root@tomcat1 local]# ln -sv apache-tomcat-7.0.70/ tomcat
`tomcat' -> `apache-tomcat-7.0.70/'

7.修改环境变量

[root@tomcat1 local]# cat /etc/profile.d/tomcat.sh
export CATALINA_HOME=/usr/local/tomcat
export PATH=$PATH:$CATALINA_HOME/bin

使其立即生效：

[root@tomcat1 local]# source /etc/profile.d/tomcat.sh

8.测试一下，启动 tomcat

[root@tomcat1 local]# catalina.sh start
Using CATALINA_BASE:   /usr/local/tomcat
Using CATALINA_HOME:   /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME:        /usr/java/jdk1.8.0_101/
Using CLASSPATH:       /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
Tomcat started.

9.查看启动的端口

[root@tomcat1 local]# netstat -ntlp
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address               Foreign Address             State       PID/Program name
tcp        0      0 0.0.0.0:22                  0.0.0.0:*                   LISTEN      1094/sshd
tcp        0      0 127.0.0.1:25                0.0.0.0:*                   LISTEN      1173/master
tcp        0      0 ::ffff:127.0.0.1:8005       :::*                        LISTEN      1383/java
tcp        0      0 :::8009                     :::*                        LISTEN      1383/java
tcp        0      0 :::8080                     :::*                        LISTEN      1383/java
tcp        0      0 :::22                       :::*                        LISTEN      1094/sshd
tcp        0      0 ::1:25                      :::*                        LISTEN      1173/master

这里有三个 java 进程：8005 是 tomcat 实例的端口，8080 是 HTTP 连接器端口，8009 是 AJP 连接器的端口：

ff

测试访问一下：

Snip20160801_15.png

注，好了到这里我们的Tomcat就安装完成了，下面我们就来看看我们安装的内容。

三、Tomcat 目录的结构

1.Tomcat的安装

其实对于完全由Java写成的Tomcat，Windows版本和Linux版本没有多大区别，比如Linux版本，在Solaris下也没有问题。这里，主要以Linux版本作为示例。

注，在安装使用Tomcat之前，先安装JDK，最好是Sun的JDK 1 .5 以上版。我们上面已经安装过了，这里我们就不在多说。

2.Tomcat的目录结构

首先，我们先来简单查看一下目录文件，

[root@tomcat1 ~]# cd /usr/local/tomcat/
[root@tomcat1 tomcat]# ls -1 -F
bin/
conf/
lib/
LICENSE
logs/
NOTICE
RELEASE-NOTES
RUNNING.txt
temp/
webapps/
work/

下面我们来简单说明下，

下面我们来说一说各目录中包含的文件，

bin目录下的文件：

[root@tomcat1 tomcat]# ls bin/
bootstrap.jar                 daemon.sh         startup.sh
catalina.bat                  digest.bat        tomcat-juli.jar
catalina.sh                   digest.sh         tomcat-native.tar.gz
catalina-tasks.xml            setclasspath.bat  tool-wrapper.bat
commons-daemon.jar            setclasspath.sh   tool-wrapper.sh
commons-daemon-native.tar.gz  shutdown.bat      version.bat
configtest.bat                shutdown.sh       version.sh
configtest.sh                 startup.bat

我们来说说最主要主文件有，

conf目录下的文件：

[root@tomcat1 tomcat]# ls -F conf/
Catalina/        catalina.properties  logging.properties  tomcat-users.xml
catalina.policy  context.xml          server.xml          web.xml

最主要的配置文件有，

lib目录下的文件：

[root@tomcat1 tomcat]# ls lib/
annotations-api.jar  el-api.jar             tomcat-api.jar      tomcat-jdbc.jar
catalina-ant.jar     jasper-el.jar          tomcat-coyote.jar   tomcat-util.jar
catalina-ha.jar      jasper.jar             tomcat-dbcp.jar     websocket-api.jar
catalina.jar         jsp-api.jar            tomcat-i18n-es.jar
catalina-tribes.jar  servlet-api.jar        tomcat-i18n-fr.jar
ecj-4.4.2.jar        tomcat7-websocket.jar  tomcat-i18n-ja.jar

包含被Tomcat使用的各种各样的jar文件。在Linux/UNIX上，任何这个目录中的文件将被附加到Tomcat的classpath中。

logs目录下的文件：

[root@tomcat1 tomcat]# ls logs/
catalina.2016-08-01.log      localhost.2016-08-01.log
catalina.out                 localhost_access_log.2016-08-01.txt
host-manager.2016-08-01.log  manager.2016-08-01.log

主要的配置文件有，

webapps目录下的文件：

[root@tomcat1 tomcat]# ls -F webapps/
docs/  examples/  host-manager/  manager/  ROOT/

含Web应用的程序 （JSP、Servlet和JavaBean等）

work目录下的配置文件：

[root@tomcat1 tomcat]# ls work/
Catalina
[root@tomcat1 tomcat]# ls work/Catalina/
localhost
[root@tomcat1 tomcat]# ls -F work/Catalina/localhost/
_/  docs/  examples/  host-manager/  manager/

它们由Tomcat自动生成，这是Tomcat放置它运行期间的中间(intermediate)文件(诸如编译的JSP文件)地方。 如果当Tomcat运行时，你删除了这个目录那么将不能够执行包含JSP的页面。

好了，Tomcat的目录结构我们就说到这了，下面我们来说说Tomcat应用程序的组成。

3.Tomcat 应用程序的组成

注，上面的内容中我们讲解了Tomcat的目录结构，其中有个目录是webapps，主要存放Web应用程序。那我们下面来说一说Web应用程序的组成。

按照Tomcat的规范，Tomcat的Web应用程序应该由如下目录组成，

(1).页面内容等文件的存放位置：*.html, *.jsp等可以有许多目录层次，由用户的网站结构而定，实现的功能应该是网站的界面，也就是用户主要的可见部分。除了HTML文件、JSP文件外，还有js（JavaScript）文件和css（样式表）文件以及其他多媒体文件等。

(2).Web-INF/web.xml 这是一个Web应用程序的描述文件。这个文件是一个XML文件，描述了Servlet和这个Web应用程序的其他组件信息，此外还包括一些初始化信息和安全约束等等。

(3).Web-INF/classes/ 这个目录及其下的子目录应该包括这个Web应用程序的所有JavaBean及Servlet等编译好的Java类文件（.class）文件，以及没有被压缩打入JAR包的其他class文件和相关资源。注意，在这个目录下的Java类应该按照其所属的包层次组织目录（即如果该.class文件具有包的定义，则该*.class文件应该放在.\WEB-INF\classes\包名下）。

(4).通常Web-INF/classes/ 这个目录下的类文件也可以打包成JAR文件，并可以放到WEB-INF下的lib目录下。如将 classes目录下的各个*.class文件打包成WebMis.jar文件（jar cvf WebMis.jar .）
注，

(5). common/lib/ 这个目录下包含了所有压缩到JAR文件中的类文件和相关文件。比如：第三方提供的Java库文件、JDBC驱动程序等。

好了，Tomcat的应用程序的能成我们就基本说到这里了，下面我们来看一下默认Web程序的目录结构。

[root@tomcat1 WEB-INF]# cd /usr/local/tomcat/
[root@tomcat1 tomcat]# ls -F
bin/   lib/     logs/   RELEASE-NOTES  temp/     work/
conf/  LICENSE  NOTICE  RUNNING.txt    webapps/
[root@tomcat1 tomcat]# cd webapps/;
[root@tomcat1 webapps]# ls -F
docs/  examples/  host-manager/  manager/  ROOT/
[root@tomcat1 webapps]# cd examples/
[root@tomcat1 examples]# ls -F
index.html  jsp/  servlets/  WEB-INF/  websocket/  websocket-deprecated/
[root@tomcat1 examples]# cd WEB-INF/
[root@tomcat1 WEB-INF]# ls -F
classes/  jsp/  jsp2/  lib/  tags/  web.xml

到这里我们的Tomcat的目录结构就讲解完成了，下面我们得来详细说说，Tomcat的配置文件。

四、Tomcat 配置文件

1.简介

查看一下默认配置文件，

[root@tomcat1 WEB-INF]# ls -F /usr/local/tomcat/conf/
Catalina/        catalina.properties  logging.properties  tomcat-users.xml
catalina.policy  context.xml          server.xml          web.xml

Tomcat的配置文件默认存放在 $CATALINA_HOME/conf 目录中，主要有以下几个：

注，下面我们对常用的配置文件进行详解。

2.server.xml

首先，我们来查看一下默认的server.xml文件，
Tomcat以面向对象的方式运行，它可以在运行时动态加载配置文件中定义的对象结构，这有点类似于apache的httpd模块的调用方式。server.xml中定义的每个主元素都会被创建为对象，并以某特定的层次结构将这些对象组织在一起。下面是默认配置，

[root@tomcat1 WEB-INF]# cd /usr/local/tomcat/conf/
[root@tomcat1 conf]# cat 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" />
  <!--Initialize Jasper prior to webapps are loaded. Documentation at /docs/jasper-howto.html -->
  <Listener className="org.apache.catalina.core.JasperListener" />
  <!-- 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 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 HTTP/1.1 Connector on port 8443
         This connector uses the BIO 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.Http11Protocol"
               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>      顶层元素，代表一个服务器
    <Service>  顶层元素，是Connector的集合，只有一个Engine
        <Connectior/>        连接器类元素，代表通信接口
        <Engine>   容器类元素，为特定的Service组件处理所有客户请求，可包含多个Host
            <Host>    为特定的虚拟主机处理所有客户请求
                <Context>     为特定的WEB应用处理所有客户请求
                </Context>
            </Host>
        </Engine>
    </Service>
</Server>
tomcat体系架构

server.xml文件中可定义的元素非常多，包括 Server, Service, Connector, Engine, Cluster, Host, Alias, Context, Realm, Valve, Manager, Listener, Resources, Resource, ResourceEnvRef, ResourceLink, WatchedResource, GlobalNameingResources, Store, Transaction, Channel, Membership, Transport, Member, ClusterListener等。

下面简单介绍几个常用组件：

(1).Server组件
如上面示例文件中定义的：

<Server port=”8005” shutdown=”SHUTDOWN”>

这会让Tomcat启动一个server实例（即一个JVM），它监听在8005端口以接收shutdown命令。各Server的定义不能使用同一个端口，这意味着如果在同一个物理机上启动了多个Server实例，必须配置它们使用不同的端口。这个端口的定义用于为管理员提供一个关闭此实例的便捷途径，因此，管理员可以直接telnet至此端口使用SHUTDOWN命令关闭此实例。不过，基于安全角度的考虑，这通常不允许远程进行。

Server的相关属性：

(2).Service组件

Service主要用于关联一个引擎和与此引擎相关的连接器，每个连接器通过一个特定的端口和协议接收入站请求，将其转发至关联的引擎进行处理。因此，Service要包含一个引擎、一个或多个连接器。

如上面示例中的定义：

<Service name=”Catalina”>

这定义了一个名为Catalina的Service，此名字也会在产生相关的日志信息时记录在日志文件当中。
Service相关的属性：

(3).Connector组件

进入Tomcat的请求可以根据Tomcat的工作模式分为如下两类：

Tomcat应该考虑工作情形并为相应情形下的请求分别定义好需要的连接器才能正确接收来自于客户端的请求。一个引擎可以有一个或多个连接器，以适应多种请求方式。

定义连接器可以使用多种属性，有些属性也只适用于某特定的连接器类型。一般说来，常见于server.xml中的连接器类型通常有4种：

如上面示例server.xml中定义的HTTP连接器：

<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

定义连接器时可以配置的属性非常多，但通常定义HTTP连接器时必须定义的属性只有“port”，定义AJP连接器时必须定义的属性只有"protocol"，因为默认的协议为HTTP。以下为常用属性的说明：

下面是一个定义了多个属性的SSL连接器：

<Connector port="8443"
 maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
 enableLookups="false" acceptCount="100" debug="0" scheme="https" secure="true"
 clientAuth="false" sslProtocol="TLS" />

(4).Engine组件

Engine是Servlet处理器的一个实例，即servlet引擎，默认为定义在 server.xml 中的 Catalina。Engine 需要 defaultHost 属性来为其定义一个接收所有发往非明确定义虚拟主机的请求的host组件。如前面示例中定义的：

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

常用的属性定义：

注，Engine容器中可以包含Realm、Host、Listener和Valve子容器。

(5).Host组件

位于Engine容器中用于接收请求并进行相应处理的主机或虚拟主机，如前面默认配置文件中定义：

<Host name="localhost" appBase="webapps"
unpackWARs="true" autoDeploy="true"
xmlValidation="false" xmlNamespaceAware="false">
</Host>

常用属性说明：

下面是虚拟主机定义示例：

<Engine name="Catalina" defaultHost="localhost">
    <Host name="localhost" appBase="webapps">
        <Context path="" docBase="ROOT"/>
        <Context path="/bbs" docBase="/web/bss"
            reloadable="true" crossContext="true"/>
    </Host>
    <Host name="mail.test.com" appBase="/web/mail">
        <Context path="" docBase="ROOT"/>
    </Host>
</Engine>

主机别名定义：
如果一个主机有两个或两个以上的主机名，额外的名称均可以以别名的形式进行定义，如下：

<Host name="www.test.com" appBase="webapps" unpackWARs="true">
    <Alias>test.com</Alias>
</Host>

(6).Context组件

Context在某些意义上类似于apache中的路径别名，一个Context定义用于标识tomcat实例中的一个Web应用程序；如下面的定义：

<!-- Tomcat Root Context -->
<Context path="" docBase="/web/webapps"/>
<!-- buzzin webapp -->
<Context path="/bbs"
 docBase="/web/threads/bbs"
 reloadable="true">
</Context>
<!-- chat server -->
 <Context path="/chat" docBase="/web/chat"/>
<!-- darian web -->
<Context path="/darian" docBase="darian"/>

在Tomcat中，每一个context定义也可以使用一个单独的XML文件进行，其文件的目录为

$CATALINA_HOME/conf/<engine name>/<hostname>。

可以用于Context中的XML元素有Loader，Manager，Realm，Resources和WatchedResource。

常用的属性定义有：

(7).Realm组件

一个Realm表示一个安全上下文，它是一个授权访问某个给定Context的用户列表和某用户所允许切换的角色相关定义的列表。因此，Realm就像是一个用户和组相关的数据库。定义Realm时惟一必须要提供的属性是classname，它是Realm的多个不同实现，用于表示此Realm认证的用户及角色等认证信息的存放位置。

下面是一个常见的使用UserDatabase的配置：

<Realm className=”org.apache.catalina.realm.UserDatabaseRealm”
 resourceName=”UserDatabase”/>

下面是一个使用JDBC方式获取用户认证信息的配置：

 <Realm className="org.apache.catalina.realm.JDBCRealm" debug="99"
 driverName="org.gjt.mm.mysql.Driver"
 connectionURL="jdbc:mysql://localhost/authority"
 connectionName="test" connectionPassword="test"
 userTable="users" userNameCol="user_name"
 userCredCol="user_pass"
 userRoleTable="user_roles" roleNameCol="role_name" />

(8).Valve组件
Valve类似于过滤器，它可以工作于Engine和Host/Context之间、Host和Context之间以及Context和Web应用程序的某资源之间。一个容器内可以建立多个Valve，而且Valve定义的次序也决定了它们生效的次序。Tomcat中实现了多种不同的Valve：

RemoteHostValve和RemoteAddrValve可以分别用来实现基于主机名称和基于IP地址的访问控制，控制本身可以通过allow或deny来进行定义，这有点类似于Apache的访问控制功能；如下面的Valve则实现了仅允许本机访问/probe：

<Context path="/probe" docBase="probe">
    <Valve className="org.apache.catalina.valves.RemoteAddrValve"
    allow="127\.0\.0\.1"/>
</Context>

其中相关属性定义有：

(9).GlobalNamingResources

应用于整个服务器的JNDI映射，此可以避免每个Web应用程序都需要在各自的web.xml创建，这在web应用程序以WAR的形式存在时尤为有用。它通常可以包含三个子元素：

(10).WatchedResource
WatchedResource可以用于Context中监视指定的webapp程序文件的改变，并且能够在监视到文件内容发生改变时重新装载此文件。

(11).Listener
Listener用于创建和配置LifecycleListener对象，而LifecycleListener通常被开发人员用来创建和删除容器。

(12).Loader
Java的动态装载功能是其语言功能强大表现之一，Servlet容器使用此功能在运行时动态装载servlet和它们所依赖的类。Loader可以用于Context中控制java类的加载。

(13).Manager
Manger对象用于实现HTTP会话管理的功能，Tomcat中有5种Manger的实现：

  1. StandardManager
    Tomcat的默认会话管理器，用于非集群环境中对单个处于运行状态的Tomcat实例会话进行管理。当Tomcat关闭时，这些会话相关的数据会被写入磁盘上的一个名叫SESSION.ser的文件，并在Tomcat下次启动时读取此文件。

  2. PersistentManager
    当一个会话长时间处于空闲状态时会被写入到swap会话对象，这对于内存资源比较吃紧的应用环境来说比较有用。
    3)DeltaManager
    用于Tomcat集群的会话管理器，它通过将改变了会话数据同步给集群中的其它节点实现会话复制。这种实现会将所有会话的改变同步给集群中的每一个节点，也是在集群环境中用得最多的一种实现方式。

  3. BackupManager
    用于Tomcat集群的会话管理器，与DeltaManager不同的是，某节点会话的改变只会同步给集群中的另一个而非所有节点。

5)SimpleTcpReplicationManager
Tomcat4时用到的版本，过于老旧了。

(14).Stores
PersistentManager必须包含一个Store元素以指定将会话数据存储至何处。这通常有两种实现方式：FileStore和JDBCStore。

(15).Resources
经常用于实现在Context中指定需要装载的但不在Tomcat本地磁盘上的应用资源，如Java类，HTML页面，JSP文件等。

(16).Cluster
专用于配置Tomcat集群的元素，可用于Engine和Host容器中。在用于Engine容器中时，Engine中的所有Host均支持集群功能。在Cluster元素中，需要直接定义一个Manager元素，这个Manager元素有一个其值为org.apache.catalina.ha.session.DeltaManager或org.apache.catalina.ha.session.BackupManager的className属性。同时，Cluster中还需要分别定义一个Channel和ClusterListener元素。

3.web.xml
web.xml基于Java Servlet规范，可被用于每一个Java servlet容器，通常有两个存放位置，$CATALINA_BASE/conf和每个Web应用程序（通常是WEB-INF/web.xml）。Tomcat在deploy一个应用程序时(包括重启或重新载入)，它首先读取conf/web.xml，而后读取WEB-INF/web.xml。

好了，到这里Tomcat服务器的安装与配置以及各组件详解就说到这里了，希望大家有所收获_…… 在前面的两篇博客中我们主要讲解了，Tomcat相关的理论知识与相关组件的讲解，从下一篇博客开始，我们将讲解Tomcat的相关操作，包括Nginx结合Tomcat、Apache结合Tomcat、Tomcat集群讲解等。

上一篇 下一篇

猜你喜欢

热点阅读