tomcat配置文件server文件详解

合集下载

tomcat安装及配置手册

Server.xml文件配置(3)
• 重要参数详解
connectionTimeout 指定超时的时间数(以毫秒为单位) Engine (表示指定service中的请求处理机，接收和处理来自Connector的请求) defaultHost 指定缺省的处理请求的主机名，它至少与其中的一个host元素的name属性值是一样的 Context (表示一个web应用程序，通常为WAR文件，关于WAR的具体信息见 servlet规范) docBase 应用程序的路径或者是WAR文件存放的路径 Path 表示此web应用程序的url的前缀，这样请求的url http://localhost:8080/path/****
Server.xml文件配置(4)
• 重要参数详解
reloadable 这个属性非常重要，如果为true，则tomcat会自动检测应用程序的 /WEB-INF/lib 和/WEB-INF/classes目录的变化，自动装载新的应用程序，我们可以在不重起tomcat的情况下改变应用程序 host (表示一个虚拟主机) name 指定主机名 appBase 应用程序基本目录，即存放应用程序的目录 unpackWARs 如果为true，则tomcat会自动将WAR文件解压，否则不解压，直接从 WAR文件中运行应用程序
UNIX版本的安装步骤(Binary)
• • • • • • • • • 根据Tomcat版本从sun网站上下载j2se(jdk) 安装jdk 设置JAVA_HOME 设置classpath 下载Tomcat的二进制版本(.tar.gz或.zip) $CATALINA_HOME/bin/startup.sh运行Tomcat Startup程序运行结束后输入http://localhost:8080/ 出现帮助文档时，表示Tomcat成功启动选择JSP Samples或Servlet Examples 表示支持了jsp及 Servlet • 以上步聚完成，则表示，成功安装了Tomcat

Tomcat中文详细手册

Tomcat中文手册Jakarta-Tomcat 简明中文版用户指南第一部分本文档提供关于Tomcat的基础信息.主要内容如下:Tomcat二进制版本安装与Tomcat相关的脚本的主要内容与server.xml相关的主要内容,Tomcat的主要配置文件如何设置Tomcat与宿主web服务器一起工作的说明如何应用Tomcat配置一个现实中的web站点希望此文档足以使新用户可以开始使用Tomcat.如找不到某方面的内容请(按以下顺序)查找Tomcat faq查找Tomcat包清单向Tomcat用户邮件列表发出问题如此疑问的答案不存在,我们鼓励把对疑问的解答放入Tomcat faq 或此文档.如对此文档有意见或建议,请发送到Tomcat的邮件列表.Getting StartedTomcat是一个带有jsp环境的servlet容器.servlet容器是一个根据用户的行为可以管理和激活servlet的运行时的shell.粗略地可以将servlet容器分为如下几类:独立的servlet容器内置有web服务器的一部分.指当使用基于Java的web服务器的情形,例如servlet容器是JavaWebServer的一个部分. 独立的servlet容器是Tomcat的默认模式.大多数的web服务器并非基于Java,因此,我们可以得出如下两种容器的模式.进程内的servlet容器servlet容器作为web服务器的插件和Java容器的实现.Web服务器插件在内部地址空间打开一个JVM(java virtual machine)使Java容器得以在内部运行.如有某个需要调用servlet的请求,,插件将取得对此请求的控制并将他传递(使用JNI)给Java容器.进程内容器对于多线程,单进程的服务器非常合适并且提供很好的运行速度,但伸缩性有所不足.进程外的servlet容器servlet容器运行于web服务器之外的地址空间且作为web服务器的插件和Java容器的实现的结合.web服务器插件和Java容器JVM使用IPC机制(通常是TCP/IP)进行通讯.当一个调用servlet 的请求到达时,插件将取得对此请求的控制并将其传递(使用IPC 等)给Java容器,进程外容器的反应时间或进程外容器引擎不如进程内容器,但进程外容器引擎在许多其他可比的范围内更好(伸缩性,稳定性等).Tomcat既可作为独立的容器(主要是用于开发与调试)又可作为对现有服务器的附加(当前支持Apache,IIS和Netscape服务器).即任何时候配置Tomcat你都必须决定如何应用他,如选择第二或第三种模式,你还需要安装一个web服务器接口.Tomcat与Jserv有何区别?Tomcat是Jserv吗?这是个常见的误解.Jserv是Servlet API2.0兼容并与Apache一起使用的容器.Tomcat是一个完全重写的并与Servlet API2.2和JSP1.1兼容的容器.Tomcat使用了一些为Jserv而写的代码,特别是Jserv的Apache 接口,但这是唯一的相同之处.怎样安装Tomcat的二进制版本?非常简单,只需:下载 zip/tar.gz 任何压缩文件,从/download/binindex.html处.解压缩此文件到某目录(如:foo).将会生成一子目录,名为”tomcat”.转换到”tomcat”目录设置一新的环境变量(TOMCAT_HOME)指向你安装的tomcat的目录WIN32平台,键入:“set TOMCAT_HOME=fo o\tomcat”Unix平台:如是bash/sh环境, 键入:”TOMCAT_HOME=foo/tomcat;export TOMCAT_HOME”如是tcsh环境, 键入:”setenv TOMCAT_HOME foo/tomcat”设置环境变量JAVA_HOME指向你JDK的目录,然后添加JAVA解释器到你的PATH环境变量.好了!现在可以运行TOMCAT并作为一个独立的Servlet容器(模式一)启动与关闭Tomcat使用”bin”目录中的脚本启动与关闭Tomcat.启动:uinx:bin/startup.shwin32:bin\startup关闭:unix:bin/shutdown.shwin32:bin\shutdownTomcat目录结构假设你已将Tomcat解压,你已得到下列目录结构:目录名--描述bin包含启动/关闭脚本conf包含不同的配置文件,包括 server.xml(Tomcat的主要配置文件)和为不同的Tomcat配置的web应用设置缺省值的文件web.xmldoc包含各种Tomcat文档lib包含Tomcat使用的jar文件.unix平台此目录下的任何文件都被加到Tomcat的classpath中logsTomcat摆放日志文件的地方srcServletAPI源文件.先别高兴,这些只有些必须在Servlet容器内实现的空接口和抽象类webapps包含web项目示例此外你可以Tomcat会创建如下目录:workTomcat自动生成,放置Tomcat运行时的临时文件(如编译后的JSP 文件).如在Tomcat运行时删除此目录.JSP页面将不能运行. classes你可以创建此目录来添加一些附加的类到类路径中.任何你加到此目录中的类都可在Tomcat的类路径中找到自身.Tomcat的脚本Tomcat是一个Java程序,因此在设置好几个环境变量后即可用命令行的方式运行.然而设置Tomcat使用的每个环境变量和如下的命令行参数乏味且易错.因此,Tomcat开发组提供了一些脚本使启动和关闭Tomcat变得轻松.注意:这些脚本仅仅是个便利的方法去启动和关闭Tomcat.你可修改他们来定制CLASSPATH,环境变量如PATH,LD_LIBRARY_PATH,等等,只要是生成一个正确的命令行即可.这些脚本是什么呢?下表列出对一般用户最重要的脚本.tomcat主脚本.设置合适的环境变量,包括CLASSPATH,TOMCAT_HOME和JAVA_HOME和用适合的命令行参数启动Tomcatstartup在后台启动Tomcat.”tomcat start”命令的替换方式shutdown关闭Tomcat.”tomcat stop”命令的替换方式对用户最重要的脚本是tomcat(tomcat.bat/tomcat.sh).其他Tomcat相关的脚本作为一个简单的面向单任务的指向Tomcat脚本(设置不同的命令行参数等)的入口.仔细考察tomcat.bat/tomcat.sh,它按以下步骤运行:在Unix下的步骤：如未指定,推测 TOMCAT_HOME如未指定,推测 JAVA_HOME设置CLASS_PATH包含:1.${TOMCAT_HOME}/classes目录(如果存在)2.${TOMCAT_HOME}/lib的一切内容3.${JAVA_HOME}/lib/tools.jar(此jar文件包含工具javac,我们需要javac处理jsp文件.运行带有设定Java环境变量的命令行参数的java命令,调入tomcat.home,和org.apache.tomcat.startup.Tomcat 作为启始类.同时也传递命令行参数到org.apache.tomcat.startup.Tomcat ,例如:执行start/stop/run 等的操作此Tomcat进程使用指向server.xml的路径,例如server.xml放置于etc/server_1.xml并且用户意图在后台启动apache,键入如下命令行:bin/tomcat.sh start –f /etc/server_1.xml在Win32下的步骤：(略)由此可见,win32版的tomcat.bat与Unix版的几乎一致.尤其在它不推测TOMCAT_HOME和JAVA_HOME的值,并且不将所有的jar文件放入类路径中.Tomcat的配置文件Tomcat的配置基于两个配置文件:1.server.xml - Tomcat的全局配置文件2.web.xml - 在Tomcat中配置不同的关系环境这一部分将讲述如何使用这些文件.我们不会包含web.xml的内部机制,这些内部机制深入到了Servlet API的细节,因此,我们将讨论涵盖servler.xml内容及web.xml在Tomcat关系环境中的用法.server.xmlserver.xml是Tomcat的主配置文件.完成两个目标:1 提供Tomcat组件的初始配置.2 说明Tomcat的结构,含义,使得Tomcat通过实例化组件完成起动及构建自身, 如在server.xml所指定的下表描述server.xml种的重要元素:Jakarta-Tomcat 简明中文版用户指南第二部分元素及其描述Serverserver.xml文件中最重要的元素.Server定义了一个Tomcat服务器.一般你不用对他担心太多.Server元素能包含Logger和ContextManager元素类型Logger此元素定义一个Logger对象,每个Logger都有一个名字去标识,也有一个纪录Logger的输出和冗余级别(描述此日志级别)和包含日志文件的路径.通常有servlet的Logger(ServletContext.log()处),JSP和Tomcat运行时的Logger.ContextManagerContextManager说明一套ContextInterceptor, RequestInterceptor , Context和他们的Connectors的配置及结构.ContextManager有几个随同提供的特性:1. 用来纪录调试信息的调试级别2. webapps/,conf/,logs/和所有已定义的环境的基本位置.用来使Tomcat可以在TOMCAT_HOME外的其他目录启动.3. 工作目录的名字ContextInterceptor&RequestInterceptor这些侦听器(interceptors)侦听具体发生在ContextManager中的事件.例如,ContextInterceptor侦听Tomcat的启动及终止事件,RequestInterceptor监视在它服务过程中用户请求需要通过的不同阶段.Tomcat的管理员不必知道太多关于侦听器的知识;另外,开发者应该知道这是如何在Tomcat中实现一个”全局”型的操作(例如安全性及每个请求日志)ConnectorConnector表示一个到用户的联接,不管是通过web服务器或直接到用户浏览器(在一个独立配置中).Connector负责管理Tomcat的工作线程和读/写连接到不同用户的端口的请求/响应.Connector的配置包含如下信息:1.句柄类2.句柄监听的TCP/IP端口3.句柄服务器端口的TCP/IP的backlog.稍后我们将在此文档中描述如何配置Connector.Context每个Context提供一个指向你放置你Web项目的Tomcat的下属目录。

Tomcat完整教程

第一章 Tomcat概述一、Tomcat简介TOMCAT是APACHE JAKARTA软件组织的一个子项目，TOMCAT是一个JSP/SERVLET容器，它是在SUN公司的JSWDK（JAVA SERVER WEB DEVELOPMENT KIT）基础上发展起来的一个JSP和SERVLET规范的标准实现，使用TOMCAT可以体验JSP和SERVLET的最新规范。

经过多年的发展，TOMCAT不仅是JSP和SERVLET规范的标准实现，而且具备了很多商业JAVA SERVLET容器的特性，并被一些企业用于商业用途。

1、TomcatTomcat在严格意义上并不是一个真正的应用服务器，它只是一个可以支持运行Serlvet/JSP 的Web容器，不过Tomcat也扩展了一些应用服务器的功能，如JNDI，数据库连接池，用户事务处理等等。

Tomcat 是一种具有JSP环境的Servlet容器。

Servlet容器是代替用户管理和调用Servlet的运行时外壳。

1．1 SERVLET容器负责处理客户请求。

当客户请求来到时，SERVLET容器获取请求，然后调用某个SERVLET，并把SERVLET的执行结果返回给客户。

当客户请求某个资源时，SERVLET容器使用SERVLETREQUEST对象把客户的请求信息封装起来，然后调用JAVA SERVLET API中定义的SERVLET的一些生命周期方法，完成SERVLET的执行，接着把SERVLET执行的要返回给客户的结果封装到SERVLETRESPONSE对象中，最后SERVLET容器把客户的请求发送给客户，完成为客户的一次服务过程。

1．2 TOMCAT的工作模式1．2．1 独立的SERVLET容器TOMCAT的默认工作模式，作为独立的SERVLET容器，是内置在WEB服务器中的一部分，是指使用基于JAVA的WEB服务器的情形。

其他两种方式是TOMCAT与其他服务器集成的方式：1．2．2 进程内的SERVLET容器SERVLET容器作为WEB服务器的插件和JAVA容器的实现。

tomcat配置文件server文件详解

一个虚拟主机） appBase应用程序基本目录，即存放应用程序的目录 unpackWARs如果为true ，则tomcat 会自动将WAR 文件解压，否则不解压,直接从WAR 文件中运行应用程序 Logger ( 表示日志，调试和错误信息）className指定logger 使用的类名，此类必须实现org 。

apache 。

catalina.Logger 接口 prefix 指定log 文件的前缀 suffix 指定log 文件的后缀 timestamp如果为true ，则log 文件名中要加入时间，如下例：localhost_log 。

2001—10-04.txt Realm ( 表示存放用户名,密码及role 的数据库)className指定Realm 使用的类名，此类必须实现org.apache 。

catalina.Realm 接口 Valve ( 功能与Logger 差不多,其prefix 和suffix 属性解释和Logger 中的一样)className 指定Valve 使用的类名,如用org.apache.catalina.valves 。

AccessLogValve 类可以记录应用程序的访问信息 directory指定log 文件存放的位置 pattern有两个值，common 方式记录远程主机名或ip 地址，用户名，日期，第一行请求的字符串，HTTP 响应代码，发送的字节数。

combined 方式比common 方式记录的值更多<Server>元素它代表整个容器,是Tomcat 实例的顶层元素.由org.apache 。

catalina.Server 接口来定义.它包含一个〈Service>元素.并且它不能做为任何元素的子元素.< Server port ="8005" shutdown ="SHUTDOWN” debug =”0" >1〉className指定实现org。

tomcat内存配置及配置参数详解

tomcat内存配置及配置参数详解1、jvm内存管理机制：1)堆(Heap)和⾮堆(Non-heap)内存按照官⽅的说法：“ 虚拟机具有⼀个堆，堆是运⾏时数据区域，所有类实例和数组的内存均从此处分配。

堆是在 Java 虚拟机启动时创建的。

”“在JVM中堆之外的内存称为⾮堆内存(Non-heap memory)”。

可以看出JVM主要管理两种类型的内存：堆和⾮堆。

简单来说堆就是Java代码可及的内存，是留给开发⼈员使⽤的；⾮堆就是JVM留给⾃⼰⽤的，所以⽅法区、JVM内部处理或优化所需的内存(如JIT编译后的代码缓存)、每个类结构(如运⾏时常数池、字段和⽅法数据)以及⽅法和构造⽅法的代码都在⾮堆内存中。

堆内存分配JVM初始分配的堆内存由-Xms指定，默认是物理内存的1/64；JVM最⼤分配的堆内存由-Xmx指定，默认是物理内存的1/4。

默认空余堆内存⼩于40%时，JVM就会增⼤堆直到-Xmx的最⼤限制；空余堆内存⼤于70%时，JVM会减少堆直到-Xms的最⼩限制。

因此服务器⼀般设置-Xms、-Xmx 相等以避免在每次GC 后调整堆的⼤⼩。

说明：如果-Xmx 不指定或者指定偏⼩，应⽤可能会导致ng.OutOfMemory错误，此错误来⾃JVM，不是Throwable的，⽆法⽤try...catch捕捉。

⾮堆内存分配JVM使⽤-XX:PermSize设置⾮堆内存初始值，默认是物理内存的1/64；由XX:MaxPermSize设置最⼤⾮堆内存的⼤⼩，默认是物理内存的1/4。

（还有⼀说：MaxPermSize缺省值和-server -client选项相关，-server选项下默认MaxPermSize为64m，-client选项下默认MaxPermSize为32m。

这个我没有实验。

）上⾯错误信息中的PermGen space的全称是Permanent Generation space，是指内存的永久保存区域。

Tomcat配置文件详解

Tomcat配置⽂件详解打开Tomcat的配置⽬录，我们会发现下⾯的配置⽂件：server.xml：Tomcat的主配置⽂件，包含Service, Connector, Engine, Realm, Valve, Hosts主组件的相关配置信息；web.xml：遵循Servlet规范标准的配置⽂件，⽤于配置servlet，并为所有的Web应⽤程序提供包括MIME映射等默认配置信息；context.xml：所有host的默认配置信息；logging.properties：⽇志相关配置；tomcat-users.xml：Realm认证时⽤到的相关⾓⾊、⽤户和密码等信息；Tomcat⾃带的manager默认情况下会⽤到此⽂件；在Tomcat中添加/删除⽤户，为⽤户指定⾓⾊等将通过编辑此⽂件实现；catalina.policy：Java相关的安全策略配置⽂件，在系统资源级别上提供访问控制的能⼒，以安全模式启动Tomcat会使⽤这个配置catalina.properties：Tomcat内部package的定义及访问相关的控制，也包括对通过类装载器装载的内容的控制；Tomcat在启动时会事先读取此⽂件的相关设置；jaspic-providers.xml：⽤户认证配置⽂件这篇博客就来介绍下这⼏个配置⽂件的作⽤，以及常⽤的配置选项。

server.xml配置server.xml是Tomcat的主配置⽂件，可以对Service, Connector, Engine, Realm, Valve, Hosts等主组件进⾏相关配置。

<!-- port: 接收shutdown指令的端⼝，默认仅允许通过本机访问，默认为8005；shutdown：发往此Server⽤于实现关闭tomcat实例的命令字符串，默认为SHUTDOWN；使⽤⽅式：telnet localhost 8005，输⼊SHUTDOWN即可关闭tomcat如果你不配置这两个属性，Tomcat的这种关闭机制还是会运⾏的。

tomcat 配置host的规则

在 Apache Tomcat 中，可以使用<Host>元素来配置虚拟主机。

虚拟主机允许在单个Tomcat 服务器上托管多个域名或主机名。

以下是关于 Tomcat 中配置虚拟主机的详细规则：
1.在 server.xml 中配置 Host 元素：
要配置虚拟主机，你需要编辑 Tomcat 的server.xml文件。

在该文件中，你可以添加多个<Host>元素，每个元素对应一个虚拟主机的配置。

例如：
2.Host 元素的属性：
–name属性指定虚拟主机的名称，通常是主机名或域名。

–appBase属性指定应用程序基础目录，它是该虚拟主机中部署的应用程序的根目录。

3.添加 Context 元素：
在<Host>元素中，你可以使用<Context>元素来配置特定的 Web 应用程序。

<Context>元素允许你指定上下文路径和应用程序的位置。

例如：
这将在虚拟主机中部署位于appBase目录下的当前应用程序。

4.配置多个虚拟主机：
你可以在server.xml文件中配置多个<Host>元素，每个元素对应一个虚拟主
机。

这允许你在同一 Tomcat 服务器上托管多个域名或主机名。

5.重启 Tomcat 服务器：
一旦你完成了server.xml文件的配置更改，你需要重新启动 Tomcat 服务器，以便让更改生效。

确保在配置虚拟主机时小心谨慎，避免出现冲突或错误配置。

配置完毕后，你可以使用不同的域名或主机名访问同一 Tomcat 服务器上的不同应用程序。

tomcat部署（配置文件）

tomcat部署（配置⽂件）⼀、启动tomcat服务器的⽅式1. 直接到tomcat服务器的bin⽬录下双击startup.bat2. 通过cmd进⼊bin⽬录，输⼊命令startup.bat1. 但这时会出现的问题是，服务器启动程序只是⼀闪⽽过，为什么呢？其实问题就是，没有Java的JDK,我们需要到环境变量配置系统变量JAVA_HOME。

我们都知道，1.5 以上的版本的JDK只需要配置path变量就可以了。

但是如果你想在机器上使⽤tomcat的话，你就必须配置JAVA_HOME，指向JDK的安装位置。

配置好之后我们就可以正常打开tomcat了，双击startup.bat，tomcat正常启动。

启动完成后，我们在浏览器地址栏上输⼊：http://localhost:8080,会得到以下的界⾯⼆、配置环境变量我们需要配置系统变量：ATALINA_BASE：指向tomcat的安装位置CATALINE_HOME:指向tomcat的安装位置Path：%CATALINA_HOME%\lib;%CATALINA_HOME%\bin三、配置tomcat的端⼝号tomcat的默认服务端⼝是8080。

可以通过配置⽂件来改变该服务端⼝，甚⾄通过修改配置⽂件让tomcat同时在多个端⼝提供服务tomcat的配置⽂件都放在conf⽬录下。

使⽤⽆格式⽂本编辑器打开该⽬录下的server.xml⽂件，定位到68⾏处<Connector port="8080" protocol="HTTP/1.1"connectionTimeout="20000"redirectPort="8443" />其中，port="8080"就是web应⽤的服务端⼝，将8080改为任意端⼝，建议使⽤1024以上的端⼝，避免与公⽤端⼝冲突。

tomcat日志配置详解

%a
这是记录访问者的IP，在日志里是127.0.0.1
%A
这是记录本地服务器的IP，在日志里是192.168.254.108
%b
这是发送信息的字节数，不涵括http头，如果字节数为0的话，显示为-
%B
看tomcat的解释，没看出来与b%的区别，但我这里显示为-1，没想明白，望知道者告知，我把官方解释贴出来吧Bytes sent, excluding HTTP headers
suffix
这就是后缀名啦，可以改成别的
pattern
这个是最主要的参数了，具体的咱们下面讲，这个参数的内容比较丰富。
resolveHosts
如果这个值是true的话，tomcat会将这个服务器IP地址通过DNS转换为主机名，如果是false，就直接写服务器IP地址啦
还有一些参数：
rotatable
%s
这个是http的状态，我这里返回的是304，咱们经常看见访问某个网页报错误500什么的，那也会返回500
%S
用户的session ID,这个session ID大家可以另外查一下详细的解释，反正每次都会生成不同的session ID
%t
这就是时间啦，好像有一个Common Log Format可以改，不过我没找到
%h
这个就是服务器名称了，如果resolveHosts为false的话，这里就是IP地址了，我的日志里是127.0.0.1
%H
访问者使用的协议，这里是HTTP/1.1
%l
这个也不太清楚，官方也说这个always return '-'官方解释：Remote logical username from identd (可能这样翻译：记录浏览者进行身份验证时提供的名字)(always returns '-')

tomcatserver.xml配置详解

tomcatserver.xml配置详解<Server>元素它代表整个容器,是Tomcat实例的顶层元素.由org.apache.catalina.Server接⼝来定义.它包含⼀个<Service>元素.并且它不能做为任何元素的⼦元素.<Server port="8005" shutdown="SHUTDOWN" debug="0">1>className指定实现org.apache.catalina.Server接⼝的类.默认值为org.apache.catalina.core.StandardServer2>port指定Tomcat监听shutdown命令端⼝.终⽌服务器运⾏时,必须在Tomcat服务器所在的机器上发出shutdown命令.该属性是必须的.3>shutdown指定终⽌Tomcat服务器运⾏时,发给Tomcat服务器的shutdown监听端⼝的字符串.该属性必须设置<Service>元素该元素由org.apache.catalina.Service接⼝定义,它包含⼀个<Engine>元素,以及⼀个或多个<Connector>,这些Connector元素共享⽤同⼀个Engine元素<Service name="Catalina"> <Service name="Apache">第⼀个<Service>处理所有直接由Tomcat服务器接收的web客户请求.第⼆个<Service>处理所有由Apahce服务器转发过来的Web客户请求1>className 指定实现org.apahce.catalina.Service接⼝的类.默认为org.apahce.catalina.core.StandardService2>name定义Service的名字<Engine>元素每个Service元素只能有⼀个Engine元素.元素处理在同⼀个<Service>中所有<Connector>元素接收到的客户请求.由org.apahce.catalina.Engine接⼝定义.<Engine name="Catalina" defaultHost="localhost" debug="0">1>className指定实现Engine接⼝的类,默认值为StandardEngine2>defaultHost指定处理客户的默认主机名,在<Engine>中的<Host>⼦元素中必须定义这⼀主机3>name定义Engine的名字在<Engine>可以包含如下元素<Logger>, <Realm>, <Value>, <Host><Host>元素它由Host接⼝定义.⼀个Engine元素可以包含多个<Host>元素.每个<Host>的元素定义了⼀个虚拟主机.它包含了⼀个或多个Web应⽤.<Host name="localhost" debug="0" appBase="webapps" unpackWARs="true" autoDeploy="true">1>className指定实现Host接⼝的类.默认值为StandardHost2>appBase指定虚拟主机的⽬录,可以指定绝对⽬录,也可以指定相对于<CATALINA_HOME>的相对⽬录.如果没有此项,默认为<CATALINA_HOME>/webapps3>autoDeploy如果此项设为true,表⽰Tomcat服务处于运⾏状态时,能够监测appBase下的⽂件,如果有新有web应⽤加⼊进来,会⾃运发布这个WEB应⽤4>unpackWARs如果此项设置为true,表⽰把WEB应⽤的WAR⽂件先展开为开放⽬录结构后再运⾏.如果设为false将直接运⾏为WAR⽂件5>alias指定主机别名,可以指定多个别名6>deployOnStartup如果此项设为true,表⽰Tomcat服务器启动时会⾃动发布appBase⽬录下所有的Web应⽤.如果Web应⽤中的server.xml没有相应的<Context>元素,将采⽤Tomcat默认的Context7>name定义虚拟主机的名字在<Host>元素中可以包含如下⼦元素<Logger>, <Realm>, <Value>, <Context><Context>元素它由Context接⼝定义.是使⽤最频繁的元素.每个<Context元素代表了运⾏在虚拟主机上的单个Web应⽤.⼀个<Host>可以包含多个<Context>元素.每个web应⽤有唯⼀的⼀个相对应的Context代表web应⽤⾃⾝.servlet容器为第⼀个web应⽤创建⼀个ServletContext对象.<Context path="/sample" docBase="sample" debug="0" reloadbale="true">1>className指定实现Context的类,默认为StandardContext类2>path指定访问Web应⽤的URL⼊⼝,注意/myweb,⽽不是myweb了事3>reloadable如果这个属性设为true, Tomcat服务器在运⾏状态下会监视在WEB-INF/classes和Web-INF/lib⽬录CLASS⽂件的改运.如果监视到有class⽂件被更新,服务器⾃重新加载Web应⽤3>cookies指定是否通过Cookies来⽀持Session,默认值为true4>useNaming指定是否⽀持JNDI,默认值为了true在<Context>元素中可以包含如下元素<Logger>, <Realm>, <Resource>, <ResourceParams><Connector>元素由Connector接⼝定义.<Connector>元素代表与客户程序实际交互的给件,它负责接收客户请求,以及向客户返回响应结果.<Connector port="8080" maxThread="50" minSpareThreads="25"maxSpareThread="75" enableLookups="false" redirectPort="8443" acceptCount="100" debug="0" connectionTimeout="20000" disableUploadTimeout="true" /><Connectionport="8009" enableLookups="false" redirectPort="8443" debug="0" protocol="AJP/1.3" />第⼀个Connector元素定义了⼀个HTTP Connector,它通过8080端⼝接收HTTP请求;第⼆个Connector元素定义了⼀个JD Connector,它通过8009端⼝接收由其它服务器转发过来的请求.Connector元素共⽤属性1>className指定实现Connector接⼝的类2>enableLookups如果设为true,表⽰⽀持域名解析,可以把IP地址解析为主机名.WEB应⽤中调⽤request.getRemoteHost⽅法返回客户机主机名.默认值为true3>redirectPort指定转发端⼝.如果当前端⼝只⽀持non-SSL请求,在需要安全通信的场命,将把客户请求转发⾄SSL的redirectPort端⼝HttpConnector元素的属性1>className实现Connector的类2>port设定Tcp/IP端⼝,默认值为8080,如果把8080改成80,则只要输⼊http://localhost/即可因为TCP/IP的默认端⼝是803>address如果服务器有⼆个以上ip地址,此属性可以设定端⼝监听的ip地址.默认情况下,端⼝会监听服务器上所有的ip地址4>bufferSize设定由端⼝创建的输⼊流的缓存⼤⼩.默认值为2048byte5>protocol设定Http协议,默认值为HTTP/1.16>maxThreads设定在监听端⼝的线程的最⼤数⽬,这个值也决定了服务器可以同时响应客户请求的最⼤数⽬.默认值为2007>acceptCount设定在监听端⼝队列的最⼤客户请求数量,默认值为10.如果队列已满,客户必须等待.8>connectionTimeout定义建⽴客户连接超时的时间.如果为-1,表⽰不限制建⽴客户连接的时间JkConnector的属性1>className实现Connector的类2>port设定AJP端⼝号3>protocol必须设定为AJP/1.3。

Tomcat6详解

Tomcat6详解Tomcat的体系结构Tomcat　6.0⽀持Servlet2.5和Jsp2.1规范，由⼀系列嵌套的组件组成。

<Connector>元素的共同属性address:如果服务器上有两个以上IP地址，该属性可以设定端⼝监听的IP地址。

默认情况下，端⼝会监听服务器上所有IP地址。

no alloTrace:布尔值，设置为true，trace http的⽅法可⽤。

默认为false。

noenableLookups:如果设为true，表⽰⽀持域名解析，可以把IP地址解析为主机名。

false表⽰跳过域名解析，直接把IP地址作为字符串返回。

默认为true。

nomastPostSize:post请求字节的最⼤⼤⼩。

默认为2097152。

noredirectPort:指定转发端⼝，如果当前端⼝只⽀持non-ssl请求，在需要安全通信的情况下，⾃动将把客户请求转发到基于SSL的redirectPort端⼝。

noscheme:连接器使⽤的协议名称。

例如可以为SSL连接器，设置属性为https。

默认为http。

nosecure:如果是SSL连接的话，设置为true，当调⽤request.getScheme()时，返回该值。

默认值为false。

noURIEncoding:URI字节的解码字符编码，默认为iso-8859-1。

nouseBodyEncodingForURI:表明如果contentType指定的编码⽤于URI查询参数，则不⽤URIEncoding。

与Tomcat4.1.x兼容。

默认为false。

noHTTP<Connector>元素属性acceptCount:设定在监听端⼝队列中的最⼤客户请求数。

默认值为１０，如果队列已满，客户请求将被拒绝。

no bufferSize:设定有端⼝创建的输⼊流的缓存⼤⼩，默认值为2048字节。

no compressableMimeTypes:设定http压缩mime类型，默认值为text/html,text/xml,text/plain。

Tomcat--各个目录详解（二）

Tomcat--各个⽬录详解（⼆）Tomcat整体⽬录：⼀、bin⽂件（存放启动和关闭tomcat脚本）其中.bat和.sh⽂件很多都是成对出现的，作⽤是⼀样的，⼀个是Windows的，⼀个是Linux。

① startup⽂件：主要是检查catalina.bat/sh 执⾏所需环境，并调⽤catalina.bat 批处理⽂件。

启动tomcat。

异常：打开可能有闪退的问题。

原因可能有以下两点： 1）缺少环境变量配置，startup会检查你的电脑环境变量是否有JAVA_HOME。

2）已经开启了Tomcat容器，再次开启端⼝号会被占⽤。

.BindException: Address already in use: JVM_Bind② catalina⽂件：真正启动Tomcat⽂件，可以在⾥⾯设置jvm参数。

异常：可能出现内存溢出错误可以考虑修改它 1）ng.OutOfMemoryError: Java heap space Tomcat默认可以使⽤的内存为128MB，在较⼤型的应⽤项⽬中，这点内存是不够的，从⽽导致客户端显⽰500错误。

Windows环境下修改catalina.bat⽂件，在⽂件开头增加如下设置：set JAVA_OPTS=-Xms256m -Xmx512m Linux环境下修改catalina.sh⽂件，在⽂件开头增加如下设置：JAVA_OPTS=’-Xms256m -Xmx512m’ 其中，-Xms设置初始化内存⼤⼩，-Xmx设置可以使⽤的最⼤内存。

2) ng.OutOfMemoryError: PermGen space PermGen space的全称是Permanent Generation space,是指内存的永久保存区域，这块内存主要是被JVM 存放Class和Meta信息的,Class在被Loader时就会被放到PermGen space中，它和存放类实例(Instance)的 Heap区域不同,GC(Garbage Collection)不会在主程序运⾏期对PermGen space进⾏清理，所以如果你的应⽤中有很CLASS的话,就很可能出现PermGen space错误，这种错误常见在web服务器对JSP进⾏pre compile的时候。

Tomcat中的Server.xml配置详解

Tomcat中的Server.xml配置详解Tomcat中的Server.xml配置详解Tomcat Server的结构图如下：该⽂件描述了如何启动Tomcat Server<Server><Listener /><GlobaNamingResources></GlobaNamingResources<Service><Connector /><Engine><Logger /><Realm /><host><Logger /><Context /></host></Engine></Service></Server>1、<Server>元素它代表整个容器，是Tomcat实例的顶层元素。

由org.apache.catalina.Server接⼝来定义。

它包含⼀个元素。

并且它不能做为任何元素的⼦元素。

<!-- ⼀个“Server”是⼀个提供完整的JVM的独⽴组件，它可以包含⼀个或多个“Service”实例。

服务器在指定的端⼝上监听shutdown命令。

注意：⼀个“Server”⾃⾝不是⼀个“Container”（容器），因此在这⾥你不可以定义诸如“Valves”或者“Loggers”⼦组件-->测试：telnet localhost 8005输⼊：SHUTDOWN结果：关闭tomcat<Server port="8005" shutdown="SHUTDOWN" debug="0">（1）className指定实现org.apache.catalina.Server接⼝的类。

配置Tomcat连接池

配置Tomcat连接池（配置server.xml文件）收藏配置Tomcat连接池：1、配置conf\server.xml，创建DataSource资源，并且为其指定参数；2、在web.xml中引用资源;3、在javabean、servlet中使用资源；server.xml文件内容<Context path="/TomcatDbPools" docBase="TomcatDbPools" debug="0" reloadable="true"><Resource name="jdbc/TomcatDbPool1" auth="Container" type="javax.sql.DataSource"/><ResourceParams name="jdbc/TomcatDbPool1">指名为哪个连接池配置参数，即为jdbc/TomcatDbPool<parameter><name>factory</name><value>mons.dbcp.BasicDataSourceFactory</value></parameter><parameter><name>maxActive</name><value>100</value></parameter><parameter><name>maxIdle</name><value>30</value></parameter><parameter><name>maxWait</name><value>10000</value></parameter><parameter><name>username</name><value></value></parameter><parameter><name>password</name><value></value></parameter><parameter><name>driverClassName</name><value>sun.jdbc.odbc.JdbcOdbcDriver</value></parameter><parameter><name>url</name><value>jdbc:odbc:bookDSN</value></parameter></ResourceParams><Resource name="jdbc/TomcatDbPool2" auth="Container" type="javax.sql.DataSource"/><ResourceParams name="jdbc/TomcatDbPool2"><parameter><name>factory</name><value>mons.dbcp.BasicDataSourceFactory</value></parameter><parameter><name>maxActive</name><value>100</value></parameter><parameter><name>maxIdle</name><value>30</value></parameter><parameter><name>maxWait</name><value>10000</value></parameter><parameter><name>username</name><value>sa</value></parameter><parameter><name>password</name><value></value></parameter><parameter><name>driverClassName</name><value>com.microsoft.jdbc.sqlserver.SQLServerDriver</value></parameter><parameter><name>url</name><value>jdbc:microsoft:sqlserver://localhost\\b:1433;DatabaseName=book</value></parameter></ResourceParams></Context>2、在web.xml中引用资源;<?xml version="1.0" encoding="GB2312"?><!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN""/dtd/web-app_2_3.dtd"><web-app><welcome-file-list><welcome-file>index.html</welcome-file></welcome-file-list> <resource-ref>--资源引用<description>ConnectionPool</description><res-ref-name>jdbc/TomcatDbPool2</res-ref-name><res-type>javax.sql.DataSource</res-type><res-auth>Container</res-auth></resource-ref></web-app>3、在javabean、servlet中使用资源；public void openConnection1(){try{ /*Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");String url="jdbc:odbc:bookDSN";conn=DriverManager.getConnection(url,"",""); *///获取连接的方式变化了(使用连接池)Context context=new InitialContext();if(context==null) {throw new Exception("No such Context");}//java:comp/env/是固定写法jdbc/TomcatDbPool1是serverl.xml中的资源的名字//用context.lookup方法从jdbc/TomcatDbPool1中得到一个数据源DataSourceds=(DataSource)context.lookup("java:comp/env/jdbc/TomcatDbPool1");conn=ds.getConnection();System.out.println("通过tomcat连接池创建连接成功!");}catch(Exception e) {System.out.println(e.getMessage()); }Web.xml配置：<?xml version="1.0" encoding="utf-8"?><!DOCTYPE web-appPUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" "/j2ee/dtds/web-app_2_2.dtd"><web-app><display-name>XCFI Application</display-name><resource-ref><description>DB Connection</description><res-ref-name>jdbc/my_mssql</res-ref-name><res-type>javax.sql.DataSource</res-type><res-auth>Container</res-auth></resource-ref><session-config><session-timeout>30</session-timeout></session-config><listener><listener-class>xcfi.website.SessionCounter</listener-class></listener><welcome-file-list><welcome-file>index.htm</welcome-file><welcome-file>index.jsp</welcome-file></welcome-file-list><taglib><taglib-uri>oscache</taglib-uri><taglib-location>/WEB-INF/tld/oscache.tld</taglib-location></taglib><servlet><servlet-name>getimage</servlet-name><servlet-class>xcfi.utily.getimage</servlet-class></servlet><servlet><servlet-name>show_product_image</servlet-name><servlet-class>show_product_image</servlet-class></servlet><servlet><servlet-name>show_mews_images</servlet-name><servlet-class>xcfi.utily.show_mews_images</servlet-class> </servlet><servlet-mapping><servlet-name>getimage</servlet-name><url-pattern>/servlet/getimage</url-pattern></servlet-mapping><servlet-mapping><servlet-name>getimage</servlet-name><url-pattern>/servlet/getimage.jsp</url-pattern></servlet-mapping><servlet-mapping><servlet-name>show_product_image</servlet-name><url-pattern>/servlet/show_product_image</url-pattern></servlet-mapping><servlet-mapping><servlet-name>show_product_image</servlet-name><url-pattern>show_product_image.jsp</url-pattern></servlet-mapping><servlet-mapping><servlet-name>show_mews_images</servlet-name><url-pattern>/servlet/show_mews_images</url-pattern></servlet-mapping></web-app>关于Tomcat与MySQL连接池问题的详解(2008-10-23 14:54:00)标签：tomcat java it分类：J2EE研究了一天，终于有所收获，希望对大家有所帮助。

【Tomcat】web应用的部署以及发布

【Tomcat】web应⽤的部署以及发布⼀、web项⽬⽂件的⽬录结构在tomcat中所有的应⽤都是放置在CATALINA_HOME/webapps下。

由于Servlet2.2之后的版本规范规定，tomcat中应⽤的⽬录结构需要满⾜固定的格式，这样便于规范⼀致性。

放置在webapps下的⽂件通常是两种格式：⼀种压缩好的项⽬⽂件，⽐如war包！⼀种是正常的⽂件夹。

如果是war包项⽬⽂件，tomcat会在启动后⾃动的把它解压缩到当前⽬录，变成可访问的⽂件夹。

项⽬⽂件的⽬录结构如下：/apps|------/WEB-INF|------/classes 编译的字节码⽂件|------/lib 需要的类库,jar包------web.xml|------/META-INF------context.xml------普通前端页⾯，jsp等等1. web.xml ⽂件：这个⽂件⽐较重要，也叫做部署描述符，⽤于配置web应⽤的相关信息。

⽐较常⽤的是监听器，过滤器，servlet，session管理，初始化参数等。

需要注意的是：注意相同项的配置顺序，tomcat会按照配置顺序进⾏执⾏或者加载。

需要注意的地⽅⽐如过滤器，还有⼀些页⾯的加载。

　2. classes⽂件夹：放置编译出的.class⽂件，⽐如你定义的某个包:com.test.hello.java 经过tomcat的启动发布后，就会在响应的应⽤下的classes⽂件夹下找到com/test/hello.class⽂件。

类似的servlet, bean, 普通的java类都会编译到此处。

3. lib ⽂件夹：放置项⽬应⽤的jar包。

⽐如使⽤了SSH，在项⽬引⽤了jar包，最后都会放在这⾥。

这个⽂件夹下的jar⽂件是不会编译到classes⽂件夹下的。

详细信息参考tomcat的类加载机制。

这个⽂件夹下的jar包是属于应⽤⾃⼰使⽤的。

tomcat根⽬录下还有⼀个lib⽂件夹，这⾥⾯存放着基本的servlet和jsp需要的jar包。

Tomcat配置说明

web.xml文件详解一、web.xml文件介绍1.web.xml文件的作用web.xml主要用来配置Filter、Listener、Servlet等。

但是要说明的是web.xml并不是必须的，一个web工程可以没有web.xml文件。

2.WEB容器的加载过程WEB容器的加载顺序是：ServletContext -> context-param -> listener -> filter -> servlet。

在web.xml文件中最好按照这种顺序配置这些元素，以兼容较低版本的Tomcat。

3.WEB容器的启动过程WEB容器启动时，加载过程顺序如下：1.启动一个WEB项目的时候，WEB容器会去读取它的配置文件web.xml，读取<listener>和<context-param>两个结点。

2.紧急着，容创建一个ServletContext（servlet上下文），这个web项目的所有部分都将共享这个上下文。

3.容器将<context-param>转换为键值对，并交给servletContext。

4.容器创建<listener>中的类实例，创建监听器。

二、web.xml配置元素1.<web-app>根元素web.xml的模式文件是由Sun公司定义的，每个web.xml文件的根元素<web-app>中，都必须标明这个web.xml使用的是哪个模式文件。

其它的元素都放在<web-app></web-app>之中，<web-app>是根节点。

<web-app version="3.0"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"></web-app>2.<icon>Web应用图标指出IDE和GUI工具用来表示Web应用的大图标和小图标。

tomcat详细配置步骤

tomcat详细配置步骤版本：tomcat6.0第一步：下载jdk和tomcat：JDK下载Tomcat下载最新的jdk为1.6.10，tomcat为6.0，建议jdk1.4以上，tomcat4.0以上第二步：安装和配置你的jdk和tomcat：执行jdk和tomcat的安装程序，然后设置按照路径进行安装即可。

1.安装jdk以后，需要配置一下环境变量，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的jdk安装在C:\Program Files\Java）：JAVA_HOME=C:\Program Files\Java\jdk1.6.0_10classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;（.;一定不能少，因为它代表当前路径)path=%JAVA_HOME%\bin接着可以写一个简单的java程序来测试JDK是否已安装成功：public class Test{public static void main(String args[]){System.out.println("This is a test program.");}}将上面的这段程序保存为文件名为Test.java的文件。

然后打开命令提示符窗口，cd到你的Test.java所在目录，然后键入下面的命令javac Test.javajava Test此时如果看到打印出来This is a test program.的话说明安装成功了，如果没有打印出这句话，你需要仔细检查一下你的配置情况。

2.安装Tomcat后，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的tomcat安装在c:\tomcat）：CATALINA_HOME：c:\tomcatCATALINA_BASE：c:\tomcatTOMCAT_HOME: C:\Tomcat然后修改环境变量中的classpath，把tomat安装目录下的common\lib下的servlet.jar追加到classpath中去，修改后的classpath 如下：classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;%CATALINA_HOME%\common\lib\servlet-api.jar; 【注意最新版本的Tomcat中可能没有common这个文件夹了。

tomcat的10个配置

1．配置系统管理〔Admin Web Application〕大多数商业化的J2EE效劳器都提供一个功能强大的管理界面，且大都采用易于理解的Web应用界面。

Tomcat按照自己的方式，同样提供一个成熟的管理工具，并且丝毫不逊于那些商业化的竞争对手。

Tomcat的Admin Web Application最初在4.1版本时出现，当时的功能包括管理context、data source、user和group等。

当然也可以管理像初始化参数，user、group、role的多种数据库管理等。

在后续的版本中，这些功能将得到很大的扩展，但现有的功能已经非常实用了。

Admin Web Application被定义在自动部署文件：CATALINA_BASE/webapps/admin.xml 。

〔译者注：CATALINA_BASE 即tomcat安装目录下的server目录〕你必须编辑这个文件，以确定Context中的docBase参数是绝对路径。

也就是说，CATALINA_BASE/webapps/admin.xml 的路径是绝对路径。

作为另外一种选择，你也可以删除这个自动部署文件，而在server.xml文件中建立一个Admin Web Application的context，效果是一样的。

你不能管理Admin Web Application这个应用，换而言之，除了删除CATALINA_BASE/webapps/admin.xml ，你可能什么都做不了。

如果你使用UserDatabaseRealm〔默认〕，你将需要添加一个user以及一个role到CATALINA_BASE/conf/tomcat-users.xml 文件中。

你编辑这个文件，添加一个名叫“admin〞的role 到该文件中，如下：<role name="admin"/>你同样需要有一个用户，并且这个用户的角色是“admin〞。

ServerProperties

ServerPropertiesSpring Boot 其默认是集成web容器的，启动⽅式由像普通Java程序⼀样，main函数⼊⼝启动。

其内置Tomcat容器或Jetty容器，具体由配置来决定（默认Tomcat）。

当然你也可以将项⽬打包成war包，放到独⽴的web容器中（Tomcat、weblogic等等），当然在此之前你要对程序⼊⼝做简单调整。

项⽬构建我们使⽤Maven或Gradle，这将使项⽬依赖、jar包管理、以及打包部署变的⾮常⽅便。

⼀、内嵌 Server 配置Spring Boot将容器内置后，它通过配置⽂件的⽅式类修改相关server配置。

先看⼀下下⾯的图，为关于server的配置列项：其中常⽤的配置只有少数⼏个，已经⽤紫⾊标记起来。

红框圈起来的部分，看名称分类就可以明⽩其作⽤。

对server的⼏个常⽤的配置做个简单说明：# 项⽬contextPath，⼀般在正式发布版本中，我们不配置server.context-path=/myspringboot# 错误页，指定发⽣错误时，跳转的URL。

请查看BasicErrorController源码便知server.error.path=/error# 服务端⼝server.port=9090# session最⼤超时时间(分钟)，默认为30server.session-timeout=60# 该服务绑定IP地址，启动服务器时如本机不是该IP地址则抛出异常启动失败，只有特殊需求的情况下才配置# server.address=192.168.16.11TomcatTomcat为Spring Boot的默认容器，下⾯是⼏个常⽤配置：1. # tomcat最⼤线程数，默认为2002. server.tomcat.max-threads=8003. # tomcat的URI编码4. server.tomcat.uri-encoding=UTF-85. # 存放Tomcat的⽇志、Dump等⽂件的临时⽂件夹，默认为系统的tmp⽂件夹（如：C:\Users\Shanhy\AppData\Local\Temp）6. server.tomcat.basedir=H:/springboot-tomcat-tmp7. # 打开Tomcat的Access⽇志，并可以设置⽇志格式的⽅法：8. #server.tomcat.access-log-enabled=true9. #server.tomcat.access-log-pattern=10. # accesslog⽬录，默认在basedir/logs11. #server.tomcat.accesslog.directory=12. # ⽇志⽂件⽬录13. logging.path=H:/springboot-tomcat-tmp14. # ⽇志⽂件名称，默认为spring.log15. logging.file=myapp.log/duyinqiang/p/5696342.htmlorg.springframework.boot:spring-boot-autoconfigure:1.3.0.M1spring-boot-autoconfigure-1.3.0.M1.jarorg.springframework.boot.autoconfigure.web.ServerProperties/** Copyright 2012-2015 the original author or authors.** Licensed 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** /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.*/package org.springframework.boot.autoconfigure.web;import java.io.File;import .InetAddress;import java.util.Collection;import java.util.HashMap;import java.util.Map;import javax.validation.constraints.NotNull;import org.apache.catalina.Context;import org.apache.catalina.connector.Connector;import org.apache.catalina.valves.AccessLogValve;import org.apache.catalina.valves.RemoteIpValve;import org.apache.coyote.AbstractProtocol;import org.apache.coyote.ProtocolHandler;import org.apache.coyote.http11.AbstractHttp11Protocol;import org.springframework.boot.context.embedded.ConfigurableEmbeddedServletContainer;import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizer;import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizerBeanPostProcessor; import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory;import org.springframework.boot.context.embedded.InitParameterConfiguringServletContextInitializer;import org.springframework.boot.context.embedded.JspServlet;import org.springframework.boot.context.embedded.Ssl;import org.springframework.boot.context.embedded.tomcat.TomcatConnectorCustomizer;import org.springframework.boot.context.embedded.tomcat.TomcatContextCustomizer;import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory; import org.springframework.boot.context.embedded.undertow.UndertowEmbeddedServletContainerFactory; import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.boot.context.properties.NestedConfigurationProperty;import org.springframework.core.Ordered;import org.springframework.util.StringUtils;/*** {@link ConfigurationProperties} for a web server (e.g. port and path settings). Will be* used to customize an {@link EmbeddedServletContainerFactory} when an* {@link EmbeddedServletContainerCustomizerBeanPostProcessor} is active.** @author Dave Syer* @author Stephane Nicoll* @author Andy Wilkinson* @author Ivan Sopov* @author Marcos Barbero*/server", ignoreUnknownFields = false)@ConfigurationProperties(prefix = "public class ServerProperties implements EmbeddedServletContainerCustomizer, Ordered {/*** Server HTTP port.*/private Integer port;/*** Network address to which the server should bind to.*/private InetAddress address;/*** Session timeout in seconds.*/private Integer sessionTimeout;/*** Context path of the application.*/private String contextPath;/*** Display name of the application.*/private String displayName = "application";@NestedConfigurationPropertyprivate Ssl ssl;/*** Path of the main dispatcher servlet.*/@NotNullprivate String servletPath = "/";private final Tomcat tomcat = new Tomcat();private final Undertow undertow = new Undertow();@NestedConfigurationPropertyprivate JspServlet jspServlet;/*** ServletContext parameters.*/private final Map<String, String> contextParameters = new HashMap<String, String>(); @Overridepublic int getOrder() {return 0;}public Tomcat getTomcat() {return this.tomcat;}public Undertow getUndertow() {return this.undertow;}public String getContextPath() {return this.contextPath;}public void setContextPath(String contextPath) {this.contextPath = contextPath;}public String getDisplayName() {return this.displayName;}public void setDisplayName(String displayName) {this.displayName = displayName;}public String getServletPath() {return this.servletPath;}public String getServletMapping() {if (this.servletPath.equals("") || this.servletPath.equals("/")) {return "/";}if (this.servletPath.contains("*")) {return this.servletPath;}if (this.servletPath.endsWith("/")) {return this.servletPath + "*";}return this.servletPath + "/*";}public String getServletPrefix() {String result = this.servletPath;if (result.contains("*")) {result = result.substring(0, result.indexOf("*"));}if (result.endsWith("/")) {result = result.substring(0, result.length() - 1);}return result;}public void setServletPath(String servletPath) {this.servletPath = servletPath;}public Integer getPort() {return this.port;}public void setPort(Integer port) {this.port = port;}public InetAddress getAddress() {return this.address;}public void setAddress(InetAddress address) {this.address = address;}public Integer getSessionTimeout() {return this.sessionTimeout;}public void setSessionTimeout(Integer sessionTimeout) {this.sessionTimeout = sessionTimeout;}public Ssl getSsl() {return this.ssl;}public void setSsl(Ssl ssl) {this.ssl = ssl;}public JspServlet getJspServlet() {return this.jspServlet;}public void setJspServlet(JspServlet jspServlet) {this.jspServlet = jspServlet;}public Map<String, String> getContextParameters() {return this.contextParameters;}public void setLoader(String value) {// no op to support Tomcat running as a traditional container (not embedded)}@Overridepublic void customize(ConfigurableEmbeddedServletContainer container) {if (getPort() != null) {container.setPort(getPort());}if (getAddress() != null) {container.setAddress(getAddress());}if (getContextPath() != null) {container.setContextPath(getContextPath());}if (getDisplayName() != null) {container.setDisplayName(getDisplayName());}if (getSessionTimeout() != null) {container.setSessionTimeout(getSessionTimeout());}if (getSsl() != null) {container.setSsl(getSsl());}if (getJspServlet() != null) {container.setJspServlet(getJspServlet());}if (container instanceof TomcatEmbeddedServletContainerFactory) {getTomcat().customizeTomcat((TomcatEmbeddedServletContainerFactory) container); }if (container instanceof UndertowEmbeddedServletContainerFactory) {getUndertow().customizeUndertow((UndertowEmbeddedServletContainerFactory) container);}container.addInitializers(new InitParameterConfiguringServletContextInitializer( getContextParameters()));}public String[] getPathsArray(Collection<String> paths) {String[] result = new String[paths.size()];int i = 0;for (String path : paths) {result[i++] = getPath(path);}return result;}public String[] getPathsArray(String[] paths) {String[] result = new String[paths.length];int i = 0;for (String path : paths) {result[i++] = getPath(path);}return result;}public String getPath(String path) {String prefix = getServletPrefix();if (!path.startsWith("/")) {path = "/" + path;}return prefix + path;}public static class Tomcat {/*** Format pattern for access logs.*/private String accessLogPattern;/*** Enable access log.*/private boolean accessLogEnabled = false;/*** Regular expression that matches proxies that are to be trusted.*/private String internalProxies = "10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|" // 10/8+ "192\\.168\\.\\d{1,3}\\.\\d{1,3}|" // 192.168/16+ "169\\.254\\.\\d{1,3}\\.\\d{1,3}|" // 169.254/16+ "127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|" // 127/8+ "172\\.1[6-9]{1}\\.\\d{1,3}\\.\\d{1,3}|" // 172.16/12+ "172\\.2[0-9]{1}\\.\\d{1,3}\\.\\d{1,3}|"+ "172\\.3[0-1]{1}\\.\\d{1,3}\\.\\d{1,3}";/*** Header that holds the incoming protocol, usually named "X-Forwarded-Proto". * Configured as a RemoteIpValve only if remoteIpHeader is also set.*/private String protocolHeader;/*** Name of the HTTP header used to override the original port value.*/private String portHeader;/*** Name of the http header from which the remote ip is extracted. Configured as a * RemoteIpValve only if remoteIpHeader is also set.*/private String remoteIpHeader;/*** Tomcat base directory. If not specified a temporary directory will be used.*/private File basedir;/*** Delay in seconds between the invocation of backgroundProcess methods.*/private int backgroundProcessorDelay = 30; // seconds/*** Maximum amount of worker threads.*/private int maxThreads = 0; // Number of threads in protocol handler /*** Maximum size in bytes of the HTTP message header.*/private int maxHttpHeaderSize = 0; // bytes/*** Character encoding to use to decode the URI.*/private String uriEncoding;/*** Controls response compression. Acceptable values are "off" to disable* compression, "on" to enable compression of responses over 2048 bytes, "force"* to force response compression, or an integer value to enable compression of * responses with content length that is at least that value.*/private String compression = "off";/*** Comma-separated list of MIME types for which compression is used.*/private String compressableMimeTypes = "text/html,text/xml,text/plain";public int getMaxThreads() {return this.maxThreads;}public void setMaxThreads(int maxThreads) {this.maxThreads = maxThreads;}public int getMaxHttpHeaderSize() {return this.maxHttpHeaderSize;}public void setMaxHttpHeaderSize(int maxHttpHeaderSize) {this.maxHttpHeaderSize = maxHttpHeaderSize;}public boolean getAccessLogEnabled() {return this.accessLogEnabled;}public void setAccessLogEnabled(boolean accessLogEnabled) {this.accessLogEnabled = accessLogEnabled;}public int getBackgroundProcessorDelay() {return this.backgroundProcessorDelay;}public void setBackgroundProcessorDelay(int backgroundProcessorDelay) {this.backgroundProcessorDelay = backgroundProcessorDelay;}public File getBasedir() {return this.basedir;}public void setBasedir(File basedir) {this.basedir = basedir;}public String getAccessLogPattern() {return this.accessLogPattern;}public void setAccessLogPattern(String accessLogPattern) {this.accessLogPattern = accessLogPattern;}public String getCompressableMimeTypes() {return pressableMimeTypes;}public void setCompressableMimeTypes(String compressableMimeTypes) {pressableMimeTypes = compressableMimeTypes;}public String getCompression() {return pression;}public void setCompression(String compression) {pression = compression;}public String getInternalProxies() {return this.internalProxies;}public void setInternalProxies(String internalProxies) {this.internalProxies = internalProxies;}public String getProtocolHeader() {return this.protocolHeader;}public void setProtocolHeader(String protocolHeader) {this.protocolHeader = protocolHeader;}public String getPortHeader() {return this.portHeader;}public void setPortHeader(String portHeader) {this.portHeader = portHeader;}public String getRemoteIpHeader() {return this.remoteIpHeader;}public void setRemoteIpHeader(String remoteIpHeader) {this.remoteIpHeader = remoteIpHeader;}public String getUriEncoding() {return this.uriEncoding;}public void setUriEncoding(String uriEncoding) {this.uriEncoding = uriEncoding;}void customizeTomcat(TomcatEmbeddedServletContainerFactory factory) {if (getBasedir() != null) {factory.setBaseDirectory(getBasedir());}customizeBackgroundProcessorDelay(factory);customizeHeaders(factory);if (this.maxThreads > 0) {customizeMaxThreads(factory);}if (this.maxHttpHeaderSize > 0) {customizeMaxHttpHeaderSize(factory);}customizeCompression(factory);if (this.accessLogEnabled) {customizeAccessLog(factory);}if (getUriEncoding() != null) {factory.setUriEncoding(getUriEncoding());}}private void customizeBackgroundProcessorDelay(TomcatEmbeddedServletContainerFactory factory) {factory.addContextCustomizers(new TomcatContextCustomizer() {@Overridepublic void customize(Context context) {context.setBackgroundProcessorDelay(Tomcat.this.backgroundProcessorDelay); }});}private void customizeHeaders(TomcatEmbeddedServletContainerFactory factory) {String remoteIpHeader = getRemoteIpHeader();String protocolHeader = getProtocolHeader();if (StringUtils.hasText(remoteIpHeader)|| StringUtils.hasText(protocolHeader)) {RemoteIpValve valve = new RemoteIpValve();valve.setRemoteIpHeader(remoteIpHeader);valve.setProtocolHeader(protocolHeader);valve.setInternalProxies(getInternalProxies());valve.setPortHeader(getPortHeader());factory.addContextValves(valve);}}@SuppressWarnings("rawtypes")private void customizeMaxThreads(TomcatEmbeddedServletContainerFactory factory) { factory.addConnectorCustomizers(new TomcatConnectorCustomizer() {@Overridepublic void customize(Connector connector) {ProtocolHandler handler = connector.getProtocolHandler();if (handler instanceof AbstractProtocol) {AbstractProtocol protocol = (AbstractProtocol) handler;protocol.setMaxThreads(Tomcat.this.maxThreads);}}});}@SuppressWarnings("rawtypes")private void customizeMaxHttpHeaderSize(TomcatEmbeddedServletContainerFactory factory) {factory.addConnectorCustomizers(new TomcatConnectorCustomizer() {@Overridepublic void customize(Connector connector) {ProtocolHandler handler = connector.getProtocolHandler();if (handler instanceof AbstractHttp11Protocol) {AbstractHttp11Protocol protocol = (AbstractHttp11Protocol) handler;protocol.setMaxHttpHeaderSize(Tomcat.this.maxHttpHeaderSize);}}});}private void customizeCompression(TomcatEmbeddedServletContainerFactory factory) { factory.addConnectorCustomizers(new TomcatConnectorCustomizer() {@Overridepublic void customize(Connector connector) {ProtocolHandler handler = connector.getProtocolHandler();if (handler instanceof AbstractHttp11Protocol) {@SuppressWarnings("rawtypes")AbstractHttp11Protocol protocol = (AbstractHttp11Protocol) handler;protocol.setCompression(coerceCompression(pression));protocol.setCompressableMimeTypes(pressableMimeTypes); }}private String coerceCompression(String compression) {if ("true".equalsIgnoreCase(compression)) {return "on";}if ("false".equalsIgnoreCase(compression)) {return "off";}return compression;}});}private void customizeAccessLog(TomcatEmbeddedServletContainerFactory factory) { AccessLogValve valve = new AccessLogValve();String accessLogPattern = getAccessLogPattern();valve.setPattern(accessLogPattern == null ? "common" : accessLogPattern);valve.setSuffix(".log");factory.addContextValves(valve);}}public static class Undertow {/*** Size of each buffer in bytes.*/private Integer bufferSize;/*** Number of buffer per region.*/private Integer buffersPerRegion;/*** Number of I/O threads to create for the worker.*/private Integer ioThreads;/*** Number of worker threads.*/private Integer workerThreads;/*** Allocate buffers outside the Java heap.*/private Boolean directBuffers;/*** Format pattern for access logs.*/private String accessLogPattern = "common";/*** Enable access log.*/private boolean accessLogEnabled = false;/*** Undertow access log directory.*/private File accessLogDir = new File("logs");public Integer getBufferSize() {return this.bufferSize;}public void setBufferSize(Integer bufferSize) {this.bufferSize = bufferSize;}public Integer getBuffersPerRegion() {return this.buffersPerRegion;}public void setBuffersPerRegion(Integer buffersPerRegion) {this.buffersPerRegion = buffersPerRegion;}public Integer getIoThreads() {return this.ioThreads;}public void setIoThreads(Integer ioThreads) {this.ioThreads = ioThreads;}public Integer getWorkerThreads() {return this.workerThreads;}public void setWorkerThreads(Integer workerThreads) {this.workerThreads = workerThreads;}public Boolean getDirectBuffers() {return this.directBuffers;}public void setDirectBuffers(Boolean directBuffers) {this.directBuffers = directBuffers;}public String getAccessLogPattern() {return this.accessLogPattern;}public void setAccessLogPattern(String accessLogPattern) {this.accessLogPattern = accessLogPattern;}public boolean isAccessLogEnabled() {return this.accessLogEnabled;}public void setAccessLogEnabled(boolean accessLogEnabled) { this.accessLogEnabled = accessLogEnabled;}public File getAccessLogDir() {return this.accessLogDir;}public void setAccessLogDir(File accessLogDir) {this.accessLogDir = accessLogDir;}void customizeUndertow(UndertowEmbeddedServletContainerFactory factory) { factory.setBufferSize(this.bufferSize);factory.setBuffersPerRegion(this.buffersPerRegion);factory.setIoThreads(this.ioThreads);factory.setWorkerThreads(this.workerThreads);factory.setDirectBuffers(this.directBuffers);factory.setAccessLogDirectory(this.accessLogDir);factory.setAccessLogPattern(this.accessLogPattern);factory.setAccessLogEnabled(this.accessLogEnabled);}}}。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

配置文件一般都在conf文件夹里，主要有server.xml，context.xml，tomcat_user.xml，web.xml四个常用配置文件，server主要是服务器设置的，例如端口设置，路径设置。

context 里设置tomcat数据源，用来连接数据库。

tomcat_user主要是用户名和密码的设置。

web 是默认首页等等之类的设置。

元素名属性解释server port指定一个端口，这个端口负责监听关闭tomcat 的请求shutdown指定向端口发送的命令字符串service name指定service 的名字Connector(表示客户端和service之间的连接)port指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求minProcessors服务器启动时创建的处理请求的线程数maxProcessors最大可以创建的处理请求的线程数enableLookups如果为true ，则可以通过调用request.getRemoteHost() 进行DNS 查询来得到远程客户端的实际主机名，若为false 则不进行DNS 查询，而是返回其ip 地址redirectPort指定服务器正在处理http 请求时收到了一个SSL 传输请求后重定向的端口号acceptCount指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理connectionTimeout指定超时的时间数( 以毫秒为单位)Engine(表示指定service 中的请求处理机，接收和处理来自Connector的请求)defaultHost指定缺省的处理请求的主机名，它至少与其中的一个host 元素的name 属性值是一样的Context(表示一个web 应用程序，通常为WAR 文件，关于WAR 的具体信息见servlet 规范)docBase应用程序的路径或者是WAR 文件存放的路径path表示此web 应用程序的url 的前缀，这样请求的url为http://localhost:8080/path/****reloadable这个属性非常重要，如果为true ，则tomcat 会自动检测应用程序的/WEB-INF/lib 和/WEB-INF/classes 目录的变化，自动装载新的应用程序，我们可以在不重起tomcat 的情况下改变应用程序host(表示name指定主机名一个虚拟主机 ) appBase 应用程序基本目录，即存放应用程序的目录 unpackWARs如果为true ，则tomcat 会自动将WAR 文件解压，否则不解压，直接从WAR 文件中运行应用程序 Logger ( 表示日志，调试和错误信息)className指定logger 使用的类名，此类必须实现org.apache.catalina.Logger 接口 prefix 指定log 文件的前缀 suffix 指定log 文件的后缀 timestamp如果为true ，则log 文件名中要加入时间，如下例:localhost_log.2001-10-04.txt Realm ( 表示存放用户名，密码及role 的数据库)className指定Realm 使用的类名，此类必须实现org.apache.catalina.Realm 接口 Valve ( 功能与Logger 差不多，其prefix 和suffix 属性解释和Logger 中的一样)className指定Valve 使用的类名，如用org.apache.catalina.valves.AccessLogValv e 类可以记录应用程序的访问信息 directory指定log 文件存放的位置 pattern有两个值，common 方式记录远程主机名或ip 地址，用户名，日期，第一行请求的字符串，HTTP 响应代码，发送的字节数。

combined 方式比common 方式记录的值更多<Server>元素它代表整个容器,是Tomcat 实例的顶层元素.由org.apache.catalina.Server 接口来定义.它包含一个<Service>元素.并且它不能做为任何元素的子元素.< Server port ="8005" shutdown ="SHUTDOWN" debug ="0" >1>className 指定实现org.apache.catalina.Server 接口的类.默认值为org.apache.catalina.core.StandardServer2>port指定Tomcat监听shutdown命令端口.终止服务器运行时,必须在Tomcat服务器所在的机器上发出shutdown命令.该属性是必须的.3>shutdown指定终止Tomcat服务器运行时,发给Tomcat服务器的shutdown监听端口的字符串.该属性必须设置<Service>元素该元素由org.apache.catalina.Service接口定义,它包含一个<Engine>元素,以及一个或多个<Connector>,这些Connector元素共享用同一个Engine元素<Service name="Catalina"><Service name="Apache">第一个<Service>处理所有直接由Tomcat服务器接收的web客户请求.第二个<Service>处理所有由Apahce服务器转发过来的Web客户请求1>className 指定实现org.apahce.catalina.Service接口的类.默认为org.apahce.catalina.core.StandardService2>name定义Service的名字<Engine>元素每个Service元素只能有一个Engine元素.元素处理在同一个<Service>中所有<Connector>元素接收到的客户请求.由org.apahce.catalina.Engine接口定义.<Engine name="Catalina"defaultHost="localhost"debug="0">1>className指定实现Engine接口的类,默认值为StandardEngine2>defaultHost指定处理客户的默认主机名,在<Engine>中的<Host>子元素中必须定义这一主机3>name定义Engine的名字在<Engine>可以包含如下元素<Logger>, <Realm>, <Value>, <Host><Host>元素它由Host接口定义.一个Engine元素可以包含多个<Host>元素.每个<Host>的元素定义了一个虚拟主机.它包含了一个或多个Web应用.<Host name="localhost"debug="0"appBase="webapps"unpackWARs="true"auto Deploy="true">1>className指定实现Host接口的类.默认值为StandardHost2>appBase指定虚拟主机的目录,可以指定绝对目录,也可以指定相对于<CATALINA_HOME>的相对目录.如果没有此项,默认为<CATALINA_HOME>/webapps3>autoDeploy如果此项设为true,表示Tomcat服务处于运行状态时,能够监测appBase下的文件,如果有新有web应用加入进来,会自运发布这个WEB应用4>unpackWARs如果此项设置为true,表示把WEB应用的WAR文件先展开为开放目录结构后再运行.如果设为false将直接运行为WAR文件5>alias指定主机别名,可以指定多个别名6>deployOnStartup如果此项设为true,表示Tomcat服务器启动时会自动发布appBase目录下所有的Web应用.如果Web应用中的server.xml没有相应的<Context>元素,将采用Tomcat默认的Context 7>name定义虚拟主机的名字在<Host>元素中可以包含如下子元素<Logger>, <Realm>, <Value>, <Context><Context>元素它由Context接口定义.是使用最频繁的元素.每个<Context元素代表了运行在虚拟主机上的单个Web应用.一个<Host>可以包含多个<Context>元素.每个web应用有唯一的一个相对应的Context代表web应用自身.servlet容器为第一个web应用创建一个ServletContext对象.<Context path="/sample"docBase="sample"debug="0"reloadbale="true">1>className指定实现Context的类,默认为StandardContext类2>path指定访问Web应用的URL入口,注意/myweb,而不是myweb了事3>reloadable如果这个属性设为true, Tomcat服务器在运行状态下会监视在WEB-INF/classes和Web-INF/lib目录CLASS文件的改运.如果监视到有class文件被更新,服务器自重新加载Web应用3>cookies指定是否通过Cookies来支持Session,默认值为true4>useNaming指定是否支持JNDI,默认值为了true在<Context>元素中可以包含如下元素<Logger>, <Realm>, <Resource>, <ResourceParams><Connector>元素由Connector接口定义.<Connector>元素代表与客户程序实际交互的给件,它负责接收客户请求,以及向客户返回响应结果.<Connector port="8080"maxThread="50"minSpareThreads="25"maxSpareThread ="75"enableLookups="false"redirectPort="8443"acceptCount="100"debug="0"connectionTimeout="20000"disableUploadTimeout="true"/><Connection port="8009"enableLookups="false"redirectPort="8443"debug="0"protocol="AJP/1.3"/>第一个Connector元素定义了一个HTTP Connector,它通过8080端口接收HTTP请求;第二个Connector元素定义了一个JD Connector,它通过8009端口接收由其它服务器转发过来的请求.Connector元素共用属性1>className指定实现Connector接口的类2>enableLookups如果设为true,表示支持域名解析,可以把IP地址解析为主机名.WEB应用中调用request.getRemoteHost方法返回客户机主机名.默认值为true3>redirectPort指定转发端口.如果当前端口只支持non-SSL请求,在需要安全通信的场命,将把客户请求转发至SSL的redirectPort端口HttpConnector元素的属性1>className实现Connector的类2>port设定Tcp/IP端口,默认值为8080,如果把8080改成80,则只要输入http://localhost即可因为TCP/IP的默认端口是803>address如果服务器有二个以上ip地址,此属性可以设定端口监听的ip地址.默认情况下,端口会监听服务器上所有的ip地址4>bufferSize设定由端口创建的输入流的缓存大小.默认值为2048byte5>protocol设定Http协议,默认值为HTTP/1.16>maxThreads设定在监听端口的线程的最大数目,这个值也决定了服务器可以同时响应客户请求的最大数目.默认值为2007>acceptCount设定在监听端口队列的最大客户请求数量,默认值为10.如果队列已满,客户必须等待.8>connectionTimeout定义建立客户连接超时的时间.如果为-1,表示不限制建立客户连接的时间JkConnector的属性1>className实现Connector的类2>port设定AJP端口号3>protocol必须设定为AJP/1.3=================================================================== =====================<Server>元素它代表整个容器,是Tomcat实例的顶层元素.由org.apache.catalina.Server接口来定义.它包含一个<Service>元素.并且它不能做为任何元素的子元素.<Server port="8005" shutdown="SHUTDOWN" debug="0">1> className指定实现org.apache.catalina.Server接口的类.默认值为org.apache.catalina.core.StandardServer2> port指定Tomcat监听shutdown命令端口.终止服务器运行时,必须在Tomcat服务器所在的机器上发出shutdown命令.该属性是必须的.3> shutdown指定终止Tomcat服务器运行时,发给Tomcat服务器的shutdown监听端口的字符串.该属性必须设置<Service>元素该元素由org.apache.catalina.Service接口定义,它包含一个<Engine>元素,以及一个或多个<Connector>,这些Connector元素共享用同一个Engine元素<Service name="Catalina"><Service name="Apache">第一个<Service>处理所有直接由Tomcat服务器接收的web客户请求.第二个<Service>处理所有由Apahce服务器转发过来的Web客户请求1> className 指定实现org.apahce.catalina.Service接口的类.默认为org.apahce.catalina.core.StandardService2> name定义Service的名字<Engine>元素每个Service元素只能有一个Engine元素.元素处理在同一个<Service>中所有<Connector>元素接收到的客户请求.由org.apahce.catalina.Engine接口定义.<Engine name="Catalina" defaultHost="localhost" debug="0">1> className指定实现Engine接口的类,默认值为StandardEngine2> defaultHost指定处理客户的默认主机名,在<Engine>中的<Host>子元素中必须定义这一主机3> name定义Engine的名字在<Engine>可以包含如下元素<Logger>, <Realm>, <Value>, <Host><Host>元素它由Host接口定义.一个Engine元素可以包含多个<Host>元素.每个<Host>的元素定义了一个虚拟主机.它包含了一个或多个Web应用.<Host name="localhost" debug="0" appBase="webapps" unpackWARs="true" autoDeploy="true">1> className指定实现Host接口的类.默认值为StandardHost2> appBase指定虚拟主机的目录,可以指定绝对目录,也可以指定相对于<CATALINA_HOME>的相对目录.如果没有此项,默认为<CATALINA_HOME>/webapps3> autoDeploy如果此项设为true,表示Tomcat服务处于运行状态时,能够监测appBase下的文件,如果有新有web应用加入进来,会自运发布这个WEB应用4> unpackWARs如果此项设置为true,表示把WEB应用的WAR文件先展开为开放目录结构后再运行.如果设为false将直接运行为WAR文件5> alias指定主机别名,可以指定多个别名6> deployOnStartup如果此项设为true,表示Tomcat服务器启动时会自动发布appBase目录下所有的Web应用.如果Web应用中的server.xml没有相应的<Context>元素,将采用Tomcat默认的Context7> name定义虚拟主机的名字在<Host>元素中可以包含如下子元素<Logger>, <Realm>, <Value>, <Context><Context>元素它由Context接口定义.是使用最频繁的元素.每个<Context元素代表了运行在虚拟主机上的单个Web应用.一个<Host>可以包含多个<Context>元素.每个web应用有唯一的一个相对应的Context代表web应用自身.servlet容器为第一个web应用创建一个ServletContext对象.<Context path="/sample" docBase="sample" debug="0" reloadbale="true">1> className指定实现Context的类,默认为StandardContext类2> path指定访问Web应用的URL入口,注意/myweb,而不是myweb了事3> reloadable如果这个属性设为true, Tomcat服务器在运行状态下会监视在WEB-INF/classes和Web-INF/lib目录CLASS文件的改运.如果监视到有class文件被更新,服务器自重新加载Web应用3> cookies指定是否通过Cookies来支持Session,默认值为true4> useNaming指定是否支持JNDI,默认值为了true在<Context>元素中可以包含如下元素<Logger>, <Realm>, <Resource>, <ResourceParams>Connector元素由Connector接口定义.<Connector>元素代表与客户程序实际交互的给件,它负责接收客户请求,以及向客户返回响应结果.<Connector port="8080" maxThread="50" minSpareThreads="25" maxSpareThread="75" enableLookups="false" redirectPort="8443" acceptCount="100" debug="0" connectionTimeout="20000" disableUploadTimeout="true" /><Connection port="8009" enableLookups="false" redirectPort="8443" debug="0" protocol="AJP/1.3" />第一个Connector元素定义了一个HTTP Connector,它通过8080端口接收HTTP请求;第二个Connector元素定义了一个JD Connector,它通过8009端口接收由其它服务器转发过来的请求.Connector元素共用属性1> className指定实现Connector接口的类2> enableLookups如果设为true,表示支持域名解析,可以把IP地址解析为主机名.WEB应用中调用request.getRemoteHost方法返回客户机主机名.默认值为true3> redirectPort指定转发端口.如果当前端口只支持non-SSL请求,在需要安全通信的场命,将把客户请求转发至SSL的redirectPort端口HttpConnector元素的属性1> className实现Connector的类2> port设定Tcp/IP端口,默认值为8080,如果把8080改成80,则只要输入http://localhost即可因为TCP/IP的默认端口是803> address如果服务器有二个以上ip地址,此属性可以设定端口监听的ip地址.默认情况下,端口会监听服务器上所有的ip地址4> bufferSize设定由端口创建的输入流的缓存大小.默认值为2048byte5> protocol设定Http协议,默认值为HTTP/1.16> maxThreads设定在监听端口的线程的最大数目,这个值也决定了服务器可以同时响应客户请求的最大数目.默认值为2007> acceptCount设定在监听端口队列的最大客户请求数量,默认值为10.如果队列已满,客户必须等待.8> connectionTimeout定义建立客户连接超时的时间.如果为-1,表示不限制建立客户连接的时间JkConnector的属性1> className实现Connector的类2> port设定AJP端口号3> protocol必须设定为AJP/1.3。