Tomcat

時間 2019-12-10 標籤 tomcat

編程語言介紹
    系統級  C  C++  go  erlang
    應用級  C#  Java  Python  Perl   Ruby  php
    虛擬機  pvm  jvm  提供運行環境
    動態網站 asp  .net  jsp

面向過程：就是分析出解決問題所須要的步驟，而後用函數把這些步驟一步一步實現，使用的時候一個一個依次調用就能夠了。 
面向對象：是把構成問題事務分解成各個對象，創建對象的目的不是爲了完成一個步驟，而是爲了描敘某個事物在整個解決問題的步驟中的行爲。

JAVA變成語言的特性
    面向對象、多線程、結構化錯誤處理
    垃圾收集、動態連接、動態擴展


POSIX: 可移植操做系統接口
    jvm將java字節碼解釋爲具體平臺的具體指令.作到跨平臺
　   Java語言的一個很是重要的特色就是與平臺的無關性。而使用Java虛擬機是實現這一特色的關鍵。通常的高級語言若是要在不一樣的平臺上運行，至少須要編譯成不一樣的目標代碼。而引入Java語言虛擬機後，Java語言在不一樣平臺上運行時不須要從新編譯。
     Java語言使用模式Java虛擬機屏蔽了與具體平臺相關的信息，使得Java語言編譯程序只需生成在jvm上運行的目標代碼（字節碼），就能夠在多種平臺上不加修改地運行。jvm在執行字節碼時，把字節碼解釋成具體平臺上的機器指令執行 1996　　JDK(Java Development Kit),包含一個JVM
　　　　　　JDK1.0   JVM Applet  AWT
1997　　JDK 1.1
　　　　　　JAR文檔格式：JDBC  JavaBean
1998　　JDK1.2
　　　　　　Sun把Java技術分爲
　　　　　　　　J2SE ==> Java 2 SE
　　　　　　　　J2EE ==> Java 2 EE
　　　　　　　　J2ME ==> Java 2 ME
       　　　　 表明性技術：EJB  Java Plug-in  Swing 
                   Jit編譯器

三個技術流派(從新命名)
J2SE ==> Java 2 SE  【java 核心API+JDK（JRE+工具及工具集API）】
J2EE ==> Java 2 EE  【Java 2 EE 核心API + Java 2 SE 】
J2ME ==> Java 2 ME

2000        JDK1.3
2002        JDK1.4
2006        Sun開源Java技術，遵循GPL，並創建OpenJDK組織管理這些代碼
2009        Oracle收購Sun

Java體系結構 Java編程語言 Java Class文件格式 Java API Java VM

java的執行
.java==>javac complier==>.class ==>jvm

jvm核心組成部分
　　class loader： 裝載java程序類文件及java API類文件（能夠調用OS native API（DSO），可是不能跨平臺，應該避免 ）
　　執行引擎
　　

java runtime data areas

方法區 Method Area　　用於存儲jvm加載的類、常量、靜態變量等，永久代。也是線程共享
堆 Heap　　　　　　　　是jvm所管理的內存中最大的一部分，線程共享，也是GC管理的主要區域，主流的算法基於分代方式進行，新生代、老年代。
Java棧 java Stack　　線程私有，存放線程本身的局部變量等信息
指令計數器Program Counter Register 線程獨佔的內存空間
本地方法棧Native Method Stackphp

configuring the heap and garbage collectorcss

Sun公司建立了第一個Servlet容器，即Java Web Server，可是JWS只是爲了演示Servlet的相應功能，因此很不穩定，
於此同時，ASF建立了JServ項目，一個能與apache整合起來的servlet容器
1999年，Sun將JWS捐給了ASF，因而兩個項目合二爲一，即Tomcat前身，第一個tomcat版本是Tomcat3.0系列，
而發佈於2001年的Tomcat4.0是在此基礎上進行了從新設計和實現，其代碼項目命名爲catalina

JavaApplet
　　是用Java語言編寫的小應用程序，能夠直接嵌入到網頁中，並可以產生特殊的效果。
Java Servlet
　　是用Java編寫的服務器端程序。其主要功能在於交互式地瀏覽和修改數據，生成動態Web內容。廣義的Servlet是指任何實現了這個Servlet接口的類

JSP(Java Server Pages)是由Sun Microsystems公司倡導、許多公司參與一塊兒創建的一種動態網頁技術標準。
　　它是在傳統的網頁HTML（標準通用標記語言的子集）文件(*.htm,*.html)中插入Java程序段(Scriptlet)和JSP標記(tag)，從而造成JSP文件，後綴名爲(*.jsp)。 
　　JSP(JavaServer Pages)是一種動態頁面技術，它的主要目的是將表示邏輯從Servlet中分離出來。
　　Java Servlet是JSP的技術基礎，並且大型的Web應用程序的開發須要Java Servlet和JSP配合才能完成。
　　JSP具有了Java技術的簡單易用，徹底的面向對象，具備平臺無關性且安全可靠，主要面向因特網的全部特色。

JSP的執行過程主要能夠分爲如下幾點：
　　客戶端發出請求。
　　Web JSP Container(jasper)將JSP轉譯成Servlet源代碼。
　　Web容器將產生的Serverlet源代碼進行編譯成.calss
　　Web JVM容器加載編譯後的.class代碼並執行
　　Web服務將結果返回給客戶端
==>當JSP網頁在執行時，JSP Container 會作檢查工做，若是發現JSP網頁有更新修改時，JSP Container 纔會再次編譯JSP成 Servlet; 若是JSP沒有更新時，就直接執行前面所產生的Servlet.

html

JAVA 2 EE: 包含的技術
　　　　JAVA 2 SE：JDK JNDI JAXP
　　　　　　JNDI　用於與LDAP服務交互的API
　　　　　　JAXP 用於分析及轉換XML
　　　　Servlet，JSP，EJB，JMS，JMX，JTA，JavaMAil
　　　　　　EJB Enterprise JavaBeans JAVA相關的諸多高級功能的實現，如RMI，對象/關係映射，跨越多個數據源的分佈式事務等
　　　　　　JMS Java Message Services 高性能異步消息服務，實現JAVA EE應用程序與非JAVA程序的透明通訊
　　　　　　JTA Java Transaction API 容許應用程序在自身的一個或多個組建中平滑地處理錯誤的機制
　　　　　　JAVAMail 經過工業標註的POP/SMTP/IMAP協議發送和接收郵件的機制
　　　　　　JMX Java Management Extensions 在程序運行時對其進行交互式監控和管理機制前端

==>而tomcat則是j2EE部分功能即j2se和 Servlet和JSP是實現java

Web Container： JDK + Servlet+ JSPmysql

商業實現：
　　WebSphere(IBM)
　　Weblogic(BEA--ORACLE)
　　Occupati
　　Oc4j
　　Glassfish
　　JBoss（核心是tomcat）

開源實現：(都須要JDK)
　　Tomcat（官方實現）
　　jetty（輕量級）
　　resin（商用收費）linux

Tomcat安裝
部署前提：
    jdk：
        Oracle JDK
        或OpenJDK (java-1.8.0-openjdk）

# rpm -ivh jdk-8u111-linux-x64.rpm
# ls /usr/java/
default jdk1.8.0_111 latest
# vi /etc/profile.d/java.sh
export JAVA_HOME=/usr/java/latest
export PATH=$JAVA_HOME/bin:$PATH
#. /etc/profile.d/java.sh
# echo $JAVA_HOME
/usr/java/latest
# java -version
java version "1.8.0_111"
Java(TM) SE Runtime Environment (build 1.8.0_111-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.111-b14, mixed mode)
# jps
2013 Jps

#tar -xf apache-tomcat-8.0.39.tar.gz -C /usr/local/
#cd /usr/local/
#ln -s apache-tomcat-8.0.39/ tomcat
#vi /etc/profile.d/tomcat.sh
export CATALINA_HOME=/usr/local/tomcat
export PATH=$CATALINA_HOME/bin:$PATH
#. /etc/profile.d/tomcat.sh

# catalina.sh version
# catalina.sh configtest    檢查語法
# catalina.sh --help
..................
commands:
debug             Start Catalina in a debugger
debug -security   Debug Catalina with a security manager
jpda start        Start Catalina under JPDA debugger
run               Start Catalina in the current window
run -security     Start in the current window with security manager
start             Start Catalina in a separate window
start -security   Start in a separate window with security manager
stop              Stop Catalina, waiting up to 5 seconds for the process to end
stop n            Stop Catalina, waiting up to n seconds for the process to end
stop -force       Stop Catalina, wait up to 5 seconds and then use kill -KILL if still running
stop n -force     Stop Catalina, wait up to n seconds and then use kill -KILL if still running
configtest        Run a basic syntax check on server.xml - check exit code for result
version           What version of tomcat are you running?
Note: Waiting for the process to end and use of the -force option require that $CATALINA_PID is definednginx

# catalina.sh start　　啓動tomcat（8080）
Using CATALINA_BASE:   /usr/local/tomcat
Using CATALINA_HOME:   /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME:        /usr/java/latest
Using CLASSPATH:       /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
Tomcat started.web

# jps
2013 Jps
1919 Bootstrap正則表達式

#ls -l /usr/local/tomcat/

    bin ——Tomcat執行腳本目錄
    conf ——Tomcat配置文件
    lib ——Tomcat運行須要的庫文件（JARS）
    logs ——Tomcat執行時的LOG文件
    temp ——Tomcat臨時文件存放目錄
    webapps ——Tomcat的主要Web發佈目錄（存放咱們本身的JSP,SERVLET,類）
    work ——Tomcat的工做目錄，Tomcat將翻譯JSP文件到的Java文件和class文件放在這裏。

# ls /usr/local/tomcat/conf/
    server.xml: Tomcat的主配置文件，包含Service, Connector, Engine, Realm, Valve, Hosts主組件的相關配置信息；
    web.xml：遵循Servlet規範標準的配置文件，用於配置servlet，併爲全部的Web應用程序提供包括MIME映射等默認配置信息；
    tomcat-user.xml：Realm認證時用到的相關角色、用戶和密碼等信息；Tomcat自帶的manager默認狀況下會用到此文件；在Tomcat中添加/刪除用戶，爲用戶指定角色等將經過編輯此文件實現；
    catalina.policy：Java相關的安全策略配置文件，在系統資源級別上提供訪問控制的能力；
    catalina.properties：Tomcat內部package的定義及訪問相關的控制，也包括對經過類裝載器裝載的內容的控制；Tomcat在啓動時會事先讀取此文件的相關設置；
    logging.properties: Tomcat經過本身內部實現的JAVA日誌記錄器來記錄操做相關的日誌，此文件即爲日誌記錄器相關的配置信息，能夠用來定義日誌記錄的組件級別以及日誌文件的存在位置等；
    context.xml：全部host的默認配置信息；

WEB GUI權限設置 
For example, to add the manager-gui role to a user named tomcat with a password of s3cret, add the following to the config file listed above.

<role rolename="manager-gui"/>
<user username="tomcat" password="s3cret" roles="manager-gui"/>

Note that for Tomcat 7 onwards, the roles required to use the manager application were changed from the single manager role to the following four roles. You will need to assign the role(s) required for the functionality you wish to access.

    manager-gui - allows access to the HTML GUI and the status pages
    manager-script - allows access to the text interface and the status pages
    manager-jmx - allows access to the JMX proxy and the status pages
    manager-status - allows access to the status pages only

The HTML interface is protected against CSRF but the text and JMX interfaces are not. To maintain the CSRF protection:

    Users with the manager-gui role should not be granted either the manager-script or manager-jmx roles.
    If the text or jmx interfaces are accessed through a browser (e.g. for testing since these interfaces are intended for tools not humans) then the browser must be closed afterwards to terminate the session.

Tomcat組件結構

Tomcat Instance:運行中的tomcat進程（表現java進程）
   Server：　　即一個tomcat實例，通常只用一個Service
   Service：　　用於將connect關聯engine組件，一個service只能屬於一個Engine，一個或多個connect
   Engine：　　Tomcat的核心組件，用於運行jsp或servlet代碼，即處理servlet請求的引擎組件。能夠有多個connect。內部容器，虛擬主機
   connect：　負責接收並解析用戶請求，將請求映射（service負責）爲Engine中運行的代碼，並將運行結果構建成響應報文。一個connect只能屬於一個引擎
   host：　　相似http中的虛擬主機（一引擎內部能夠包含多個host，tomcat通常使用基於主機名）
   context：相似於httpd中的alias,描述訪問路徑
   realm：    訪問認證
注意：每一個組件都由「類"來實現，有些組件還不止一種
   頂級類組件：Server
   服務類組件：Service
   容器類組件：便可以部署webapp的組件：engine、host、context
   鏈接類組件：connect
   被嵌套類組件：valve、logger、realm（認證）

Tomcat 應用程序的組成
按照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\包名下）。

/: webapp的根目錄
   WEB-INF/:    當前webapp的私有資源目錄，一般存當前webapp自用的web.xml
   META-INF/:   當前webapp的私有資源目錄,一般存放當前webapp自用的context.xml
   classes/:    此webapp的私有類,包含全部服務器端類及當前應用程序相關的其餘第三方類等
   lib/         此webapp的私有類，被打包爲jar格式類，包含全部用到的JAR文件
   index.jsp:   webapp的主頁

用於tomcat的webapp既能夠多個獨立的文件組成，也能夠是jar打包後的單個文件，這些打包後的文件的擴展名能夠用於判斷其文件按的類型
   EJB一般打包爲.jar
   webapp一般打包爲.war
   資源適配器一般打包爲.rar
   企業級應用程序一般打包爲.ear,它一般是整合的EJB、webapp及資源適配器文件
   web服務器一般會打包爲.ear或.war

Tomcat 配置文件(轉http://freeloda.blog.51cto.com/2033581/1299644)

1.簡介

查看一下默認配置文件，

 
         [root@tomcat ~] 
         # cd /usr/local/tomcat/conf/ 
        
         [root@tomcat conf] 
         # ls 
        
         Catalina catalina.policy catalina.properties context.xml logging.properties server.xml tomcat- 
         users 
         .xml web.xml

Tomcat的配置文件默認存放在$CATALINA_HOME/conf目錄中，主要有如下幾個：

server.xml: Tomcat的主配置文件，包含Service, Connector, Engine, Realm, Valve, Hosts主組件的相關配置信息；
web.xml：遵循Servlet規範標準的配置文件，用於配置servlet，併爲全部的Web應用程序提供包括MIME映射等默認配置信息；
tomcat-user.xml：Realm認證時用到的相關角色、用戶和密碼等信息；Tomcat自帶的manager默認狀況下會用到此文件；在Tomcat中添加/刪除用戶，爲用戶指定角色等將經過編輯此文件實現；
catalina.policy：Java相關的安全策略配置文件，在系統資源級別上提供訪問控制的能力；
catalina.properties：Tomcat內部package的定義及訪問相關的控制，也包括對經過類裝載器裝載的內容的控制；Tomcat在啓動時會事先讀取此文件的相關設置；
logging.properties: Tomcat經過本身內部實現的JAVA日誌記錄器來記錄操做相關的日誌，此文件即爲日誌記錄器相關的配置信息，能夠用來定義日誌記錄的組件級別以及日誌文件的存在位置等；
context.xml：全部host的默認配置信息；

注，下面咱們對經常使用的配置文件進行詳解。

2.server.xml

首先，咱們來查看一下默認的server.xml文件，

Tomcat以面向對象的方式運行，它能夠在運行時動態加載配置文件中定義的對象結構，這有點相似於apache的httpd模塊的調用方式。server.xml中定義的每一個主元素都會被建立爲對象，並以某特定的層次結構將這些對象組織在一塊兒。下面是默認配置，

 
         [root@tomcat 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">  
        
         <!-- 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 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 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 &quot;%r&quot; %s %b" /> 
        
         </Host> 
        
          </Engine>  
        
          </Service>  
        
         </Server>

注，看上去很複雜。其實，大部分都是註釋。下面是一個簡圖說明了各組件之間的關係！

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的相關屬性：

className: 用於實現此Server容器的徹底限定類的名稱，默認爲org.apache.catalina.core.StandardServer；
port: 接收shutdown指令的端口，默認僅容許經過本機訪問，默認爲8005；
shutdown：發往此Server用於實現關閉tomcat實例的命令字符串，默認爲SHUTDOWN；

(2).Service組件

Service主要用於關聯一個引擎和與此引擎相關的鏈接器，每一個鏈接器經過一個特定的端口和協議接收入站請求交將其轉發相當聯的引擎進行處理。所以，Service要包含一個引擎、一個或多個鏈接器。

如上面示例中的定義：
<Service name=」Catalina」>

這定義了一個名爲Catalina的Service，此名字也會在產生相關的日誌信息時記錄在日誌文件當中。

Service相關的屬性：

className：用於實現service的類名，通常都是org.apache.catalina.core.StandardService。
name：此服務的名稱，默認爲Catalina；

(3).Connector組件

進入Tomcat的請求能夠根據Tomcat的工做模式分爲以下兩類：

Tomcat做爲應用程序服務器：請求來自於前端的web服務器，這多是Apache, IIS, Nginx等；
Tomcat做爲獨立服務器：請求來自於web瀏覽器；

Tomcat應該考慮工做情形併爲相應情形下的請求分別定義好須要的鏈接器才能正確接收來自於客戶端的請求。一個引擎能夠有一個或多個鏈接器，以適應多種請求方式。

定義鏈接器可使用多種屬性，有些屬性也只適用於某特定的鏈接器類型。通常說來，常見於server.xml中的鏈接器類型一般有4種：

HTTP鏈接器
SSL鏈接器
AJP 1.3鏈接器
proxy鏈接器

如上面示例server.xml中定義的HTTP鏈接器：

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

定義鏈接器時能夠配置的屬性很是多，但一般定義HTTP鏈接器時必須定義的屬性只有「port」，定義AJP鏈接器時必須定義的屬性只有"protocol"，由於默認的協議爲HTTP。如下爲經常使用屬性的說明：

address：指定鏈接器監聽的地址，默認爲全部地址，即0.0.0.0；
maxThreads：支持的最大併發鏈接數，默認爲200；
port：監聽的端口，默認爲0；
protocol：鏈接器使用的協議，默認爲HTTP/1.1，定義AJP協議時一般爲AJP/1.3；
redirectPort：若是某鏈接器支持的協議是HTTP，當接收客戶端發來的HTTPS請求時，則轉發至此屬性定義的端口；
connectionTimeout：等待客戶端發送請求的超時時間，單位爲毫秒，默認爲60000，即1分鐘；
enableLookups：是否經過request.getRemoteHost()進行DNS查詢以獲取客戶端的主機名；默認爲true；
acceptCount：設置等待隊列的最大長度；一般在tomcat全部處理線程均處於繁忙狀態時，新發來的請求將被放置於等待隊列中；

下面是一個定義了多個屬性的SSL鏈接器：

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

Tomcat鏈接器架構：基於Apache作爲Tomcat前端的架構來說，Apache經過mod_jk、mod_jk2或mod_proxy模塊與後端的Tomcat進行數據交換。而對Tomcat來講，每一個Web容器實例都有一個Java語言開發的鏈接器模塊組件，在Tomcat中，這個鏈接器是org.apache.catalina.Connector類。這個類的構造器能夠構造兩種類別的鏈接器：HTTP/1.1負責響應基於HTTP/HTTPS協議的請求，AJP/1.3負責響應基於AJP的請求。但能夠簡單地經過在server.xml配置文件中實現鏈接器的建立，但建立時所使用的類根據系統是支持APR(Apache Portable Runtime)而有所不一樣。APR是附加在提供了通用和標準API的操做系統之上一個通信層的本地庫的集合，它可以爲使用了APR的應用程序在與Apache通訊時提供較好伸縮能力時帶去平衡效用。同時，須要說明的是，mod_jk2模塊目前已經再也不被支持了，mod_jk模塊目前還apache被支持，但其項目活躍度已經大大下降。所以，目前更經常使用的方式是使用mod_proxy模塊。

若是支持APR：
    HTTP/1.1：org.apache.cotote.http11.Http11AprProtocol
    AJP/1.3：org.apache.coyote.ajp.AjpAprProtocol

若是不支持APR：
    HTTP/1.1: org.apache.coyote.http11.Http11Protocol
    AJP/1.3: org.apache.jk.server.JkCoyoteHandler

鏈接器協議：
Tomcat的Web服務器鏈接器支持兩種協議：AJP和HTTP，它們均定義了以二進制格式在Web服務器和Tomcat之間進行數據傳輸，並提供相應的控制命令。
AJP(Apache JServ Protocol)協議：
目前正在使用的AJP協議的版本是經過JK和JK2鏈接器提供支持的AJP13，它基於二進制的格式在Web服務器和Tomcat之間傳輸數據，而此前的版本AJP10和AJP11則使用文本格式傳輸數據。

HTTP協議:
誠如其名稱所表示，其是使用HTTP或HTTPS協議在Web服務器和Tomcat之間創建通訊，此時，Tomcat就是一個徹底功能的HTTP服務器，它須要監聽在某端口上以接收來自於商前服務器的請求。

(4).Engine組件

Engine是Servlet處理器的一個實例，即servlet引擎，默認爲定義在server.xml中的Catalina。Engine須要defaultHost屬性來爲其定義一個接收全部發往非明肯定義虛擬主機的請求的host組件。如前面示例中定義的：
<Engine name="Catalina" defaultHost="localhost">

經常使用的屬性定義：

defaultHost：Tomcat支持基於FQDN的虛擬主機，這些虛擬主機能夠經過在Engine容器中定義多個不一樣的Host組件來實現；但若是此引擎的鏈接器收到一個發往非非明肯定義虛擬主機的請求時則須要將此請求發往一個默認的虛擬主機進行處理，所以，在Engine中定義的多個虛擬主機的主機名稱中至少要有一個跟defaultHost定義的主機名稱同名；
name：Engine組件的名稱，用於日誌和錯誤信息記錄時區別不一樣的引擎；

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

(5).Host組件

位於Engine容器中用於接收請求並進行相應處理的主機或虛擬主機，如前面默認配置文件中定義：

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

經常使用屬性說明：

appBase：此Host的webapps目錄，即存放非歸檔的web應用程序的目錄或歸檔後的WAR文件的目錄路徑；可使用基於$CATALINA_HOME的相對路徑；
autoDeploy：在Tomcat處於運行狀態時放置於appBase目錄中的應用程序文件是否自動進行deploy；默認爲true；
unpackWars：在啓用此webapps時是否對WAR格式的歸檔文件先進行展開；默認爲true；

下面是虛擬主機定義示例：

 
         <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>/<host name>。能夠用於Context中的XML元素有Loader，Manager，Realm，Resources和WatchedResource。

經常使用的屬性定義有：

docBase：相應的Web應用程序的存放位置；也可使用相對路徑，起始路徑爲此Context所屬Host中appBase定義的路徑；切記，docBase的路徑名不能與相應的Host中appBase中定義的路徑名有包含關係，好比，若是appBase爲deploy，而docBase毫不能爲deploy-bbs類的名字；
path：相對於Web服務器根路徑而言的URI；若是爲空「」，則表示爲此webapp的根路徑；若是context定義在一個單獨的xml文件中，此屬性不須要定義；
reloadable：是否容許從新加載此context相關的Web應用程序的類；默認爲false；

(7).Realm組件
一個Realm表示一個安全上下文，它是一個受權訪問某個給定Context的用戶列表和某用戶所容許切換的角色相關定義的列表。所以，Realm就像是一個用戶和組相關的數據庫。定義Realm時唯一必需要提供的屬性是classname，它是Realm的多個不一樣實現，用於表示此Realm認證的用戶及角色等認證信息的存放位置。

JAASRealm：基於Java Authintication and Authorization Service實現用戶認證；
JDBCRealm：經過JDBC訪問某關係型數據庫表實現用戶認證；
JNDIRealm：基於JNDI使用目錄服務實現認證信息的獲取；
MemoryRealm：查找tomcat-user.xml文件實現用戶信息的獲取；
UserDatabaseRealm：基於UserDatabase文件(一般是tomcat-user.xml)實現用戶認證，它實現是一個徹底可更新和持久有效的MemoryRealm，所以可以跟標準的MemoryRealm兼容；它經過JNDI實現；

下面是一個常見的使用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：

AccessLogValve：　　訪問日誌Valve
ExtendedAccessValve：　　擴展功能的訪問日誌Valve
JDBCAccessLogValve：　　經過JDBC將訪問日誌信息發送到數據庫中；
RequestDumperValve：　　請求轉儲Valve；
RemoteAddrValve：　　基於遠程地址的訪問控制；
RemoteHostValve：　　基於遠程主機名稱的訪問控制；
SemaphoreValve：　　用於控制Tomcat主機上任何容器上的併發訪問數量；
JvmRouteBinderValve：在配置多個Tomcat爲以Apache經過mod_proxy或mod_jk做爲前端的集羣架構中，當指望中止某節點時，能夠經過此Valve將用記請求定　　　　　　　　　　向至備用節點；使用此Valve，必須使用JvmRouteSessionIDBinderListener；
ReplicationValve：專用於Tomcat集羣架構中，能夠在某個請求的session信息發生更改時觸發session數據在各節點間進行復制；
SingleSignOn：將兩個或多個須要對用戶進行認證webapp在認證用戶時鏈接在一塊兒，即一次認證便可訪問全部鏈接在一塊兒的webapp；
ClusterSingleSingOn：對SingleSignOn的擴展，專用於Tomcat集羣當中，須要結合ClusterSingleSignOnListener進行工做；

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 
         >

其中相關屬性定義有：

className：相關的java實現的類名，相應於分別應該爲org.apache.catalina.valves.RemoteHostValve或org.apache.catalina.valves.RemoteAddrValve；
allow：以逗號分開的容許訪問的IP地址列表，支持正則表達式，所以，點號「.」用於IP地址時須要轉義；僅定義allow項時，非明確allow的地址均被deny；
deny: 以逗號分開的禁止訪問的IP地址列表，支持正則表達式；使用方式同allow；

(9).GlobalNamingResources

應用於整個服務器的JNDI映射，此能夠避免每一個Web應用程序都須要在各自的web.xml建立，這在web應用程序以WAR的形式存在時尤其有用。它一般能夠包含三個子元素：

Environment;
Resource;
ResourceEnvRef;

(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集羣的會話管理器，它經過將改變了會話數據同步給集羣中的其它節點實現會話複製。這種實現會將全部會話的改變同步給集羣中的每個節點，也是在集羣環境中用得最多的一種實現方式。

4) 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元素。

Channel 用於Cluster中給集羣中同一組中的節點定義通訊「信道」。Channel中須要至少定義Membership、Receiver和Sender三個元素，此外還有一個可選元素Interceptor。
Membership 用於Channel中配置同一通訊信道上節點集羣組中的成員狀況，即監控加入當前集羣組中的節點並在各節點間傳遞心跳信息，並且能夠在接收不到某成員的心跳信息時將其從集羣節點中移除。Tomcat中Membership的實現是org.apache.catalina.tribes.membership.McastService。
Sender 用於Channel中配置「複製信息」的發送器，實現發送須要同步給其它節點的數據至集羣中的其它節點。發送器不須要屬性的定義，但能夠在其內部定義一個Transport元素。
Transport 用於Sender內部，配置數據如何發送至集羣中的其它節點。Tomcat有兩種Transport的實現：
1) PooledMultiSender
基於Java阻塞式IO，能夠將一次將多個信息併發發送至其它節點，但一次只能傳送給一個節點。
2)PooledParallelSener
基於Java非阻塞式IO，即NIO，能夠一次發送多個信息至一個或多個節點。
Receiver 用於Channel定義某節點如何從其它節點的Sender接收復制數據，Tomcat中實現的接收方式有兩種BioReceiver和NioReceiver。

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集羣講解等。

部署（deployment）webapp相關的操做（server.xml）
deploy：部署，即將webapp的源文件放置於目標目錄，配置tomcat服務器可以基於context.xml文件中定義的路徑來訪問此webapp；將其特有的類經過class loader裝載至tomcat
兩種方式：
　　自動部署 auto deploy(生產通常不用)
　　手動部署
　　　　1、冷部署：把webapp複製到指定位置，然後啓動tomcat
　　　　2、熱部署：不中止tomcat的前提下進行的部分。部署工具，主頁的manager、ant腳本、tcd（tomcat client deployer）等
undeploy:　　反部署,中止webapp，並從tomcat實例移除deploy產生的文件和名稱
stop：　　　　中止,再也不向用戶提供服務，卸載當前應用程序的全部類。不過其依然會保留已deploy的文件及名稱，並可用於後續的redeploy或starting
start：　　　啓動處於「中止狀態的webapp」，從新壯哉當前應用的類至類加載器，並開啓服務
redeploy:　　從新部署，用於更新deploy後的某應用程序或應用程序的部份內容，當redeploy整個應用程序時，當前全部模塊都必需要redeploy成功，不然整個webapp將會中止

演示配置虛擬主機
首先，咱們來修改一下配置文件，
# vim server.xml
#增長下面幾行  
<Host name="www.test.com" appBase="/web/webapp"
   unpackWARs="true" autoDeploy="true">
     <Context path="/" docBase="/web/webapp" reloadable="true"/>
</Host>

接下來咱們來建立文檔目錄與測試頁面，
# mkdir -pv /web/webapp
# cd /web/webapp
# vim index.jsp
<%@ page language="java" %> <%@ page import="java.util.*" %> <html> <head> <title>JSP test page.</title> </head> <body> <% out.println("Welcome to test. Site, http://www.test.com"); %> </body> </html>

作好host解析進行測試

爲了幫助你們理解，咱們這裏再次講解一下，Host組件與Context組件以及相關屬性。

Host組件：
位於Engine容器中用於接收請求並進行相應處理的主機或虛擬主機，如前面咱們自定義的內容：
  
<Host name="www.test.com" appBase="/web/webapp"
   unpackWARs="true" autoDeploy="true">
     <Context path="/" docBase="/web/webapp" reloadable="true"/>
</Host>

經常使用屬性說明：
　　name：定義虛擬主機的域名
　　appBase：此Host的webapps目錄，即存放非歸檔的web應用程序的目錄或歸檔後的WAR文件的目錄路徑；可使用基於$CATALINA_HOME的相對路徑；
　　autoDeploy：在Tomcat處於運行狀態時放置於appBase目錄中的應用程序文件是否自動進行deploy；默認爲true；
　　unpackWars：在啓用此webapps時是否對WAR格式的歸檔文件先進行展開；默認爲true； 

主機別名定義：
若是一個主機有兩個或兩個以上的主機名，額外的名稱都可以以別名的形式進行定義，以下：    
<Host name="www.test.com" appBase="webapps" unpackWARs="true">
 <Alias>web.test.com</Alias>
</Host>
 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>/<host name>。能夠用於Context中的XML元素有Loader，Manager，Realm，Resources和WatchedResource。

經常使用的屬性定義有：
    docBase：相應的Web應用程序的存放位置；也可使用相對路徑，起始路徑爲此Context所屬Host中appBase定義的路徑；切記，docBase的路徑名不能與相應的Host中appBase中定義的路徑名有包含關係，好比，若是appBase爲deploy，而docBase毫不能爲deploy-bbs類的名字；
    path：相對於Web服務器根路徑而言的URI；若是爲空「」，則表示爲此webapp的根路徑；若是context定義在一個單獨的xml文件中，此屬性不須要定義；
    reloadable：是否容許從新加載此context相關的Web應用程序的類；默認爲false； 

爲了便於你們理解，咱們這裏再定義一個Context並測試一下，
咱們先來修改一下配置文件   
# vim server.xml
<Host name="www.test.com" appBase="/web/webapp"
    unpackWARs="true" autoDeploy="true">
      <Context path="/" docBase="/web/webapp" reloadable="true"/>
      <Context path="/test" docBase="/web/test" reloadable="true"/> #增長這一行
</Host>

下面來增長目錄文檔與測試文件
# mkdir /web/test
# cd /web/test
# vim index.jsp
<%@ page language="java" %>
<html>
 <head><title>TomcatA</title></head>
 <body>
  <h1><font color="red">TomcatA </h1>
  <table align="centre" border="1">
   <tr>
    <td>Session ID</td>
  <% session.setAttribute("abc","abc"); %>
    <td><%= session.getId() %></td>
   </tr>
   <tr>
    <td>Created on</td>
    <td><%= session.getCreationTime() %></td>
   </tr>
  </table>
 </body>
</html>

測試一下配置文件是否有錯並啓動Tomcat，
# catalina configtest
# service tomcat start

Tomcat圖形管理接口
    Server Status 主要用來查看服務器的狀態
    Manager App 主要用來管理應用程序的部署及監控
    Host Manager 主要用來管理虛擬主機 
下面咱們就來具休的配置一下，你們能夠看到，你點擊任何一個按鈕都要輸入用戶名和密碼的，在咱們配置以前咱們先來講一下，Tomcat的Manager功能，

Manager的四個管理角色：
    manager-gui - allows access to the HTML GUI and the status pages
    manager-script - allows access to the text interface and the status pages
    manager-jmx - allows access to the JMX proxy and the status pages
    manager-status - allows access to the status pages only 

下面咱們就來啓用manager功能，修改tomcat-user.xml文件，添加以下行：
    
<role rolename="manager-gui"/>
<role rolename="admin-gui"/>
<user username="tomcat" password="tomcat" roles="manager-gui,admin-gui"/>
簡單解釋一下，Tomcat有內置的角色，咱們這裏增長了兩個角色一個爲manager-gui，另外一個爲admin-gui，用戶名和密碼都爲tomcat。



部署JSP網站案例
# vi /usr/local/tomcat/conf/server.xml 
</Host><Host name="www.test.com" appBase="/web"
   unpackWARs="true" autoDeploy="true">
     <Context path="/jenkins" docBase="/web/webapp/jenkins" reloadable="true"/>
</Host>
將jenkins.war放置在/web/webapp/目錄，並重啓catalina
瀏覽器http://www.test.com:8080/ 根據提示進行安裝






2、Nginx反向代理Tomcat服務器

 安裝一臺nginx，配置一下Nginx反向代理Tomcat服務器
# vim nginx.conf
    location / {
      #root  html;
      #index index.html index.htm;
      proxy_pass http://192.168.0.83:8080; #註釋默認兩行，新增一行。
    }
# /usr/local/nginx/sbin/nginx -s reload  

tomcat服務器配置    
# vim /usr/local/tomcat/conf/server.xml
  <Engine name="Catalina" defaultHost="www.test.com">
# catalina.sh stop
# catalina.sh start

你們能夠看到咱們成功設置了nginx反向代理tomcat服務器。好了，你們能夠看到，咱們網站上有不少的圖片，每次訪問都要去後端的tomcat服務器上去取，很消耗服務器資源。咱們下面將設置在nginx服務器上緩存圖片。

Nginx將圖片緩存到本地
# cat nginx.conf
............
http {
  include    mime.types;
  default_type application/octet-stream;
  #log_format main '$remote_addr - $remote_user [$time_local] "$request" '
  #         '$status $body_bytes_sent "$http_referer" '
  #         '"$http_user_agent" "$http_x_forwarded_for"';
  #access_log logs/access.log main;
  sendfile    on;
  #tcp_nopush   on;
  #keepalive_timeout 0;
  keepalive_timeout 65;
  #gzip on;
  proxy_cache_path /nginx/cache levels=1:2 keys_zone=first:10m inactive=24h max_size=1G; #新建緩存路徑與相關屬性
  upstream backend { #創建後端tomcat服務器
  server 192.168.18.201 weight=1;
  }
  server {
    listen    80;
    server_name localhost;
    #charset koi8-r;
    #access_log logs/host.access.log main;
    location / {
      #root  html;
      #index index.html index.htm;
      #proxy_pass http://192.168.18.201/; #註釋原來的代理設置
      proxy_pass http://backend/; #啓動後端服務器
    }
  location ~* "\.(jpg|jpeg|png|gif|html|css|js)$" { #緩存圖片與靜態內容
    proxy_pass http://backend;
    proxy_cache first;
    proxy_cache_valid 200 24h; #200狀態緩存24小時
    proxy_cache_valid 302 10m; #302狀態緩存10分鐘
    add_header X-Cache-Status $upstream_cache_status; #在http頭部增長一個字段顯示是否命令緩存
  }
    #error_page 404       /404.html;
    # redirect server error pages to the static page /50x.html
    #
    error_page  500 502 503 504 /50x.html;
    location = /50x.html {
      root  html;
    }
  }
}

下面咱們來新建緩存目錄， 
# mkdir -pv /nginx/cache
mkdir: 已建立目錄 "/nginx"
mkdir: 已建立目錄 "/nginx/cache"
  
# /usr/local/nginx/sbin/nginx -s reload

訪問後
#ls /nginx/cache/
0 1 2 3 4 5 6 7 8 9 b c d e



Nginx將請求實現動靜分離

首先，咱們來講一下咱們要實現的效果，上面咱們已經將靜態內容緩存在nginx服務器上，咱們想讓用戶請求的靜態內容到nginx去取，動態內容到tomcat服務器上去取，這就能實現動靜分享效果。一樣的首先咱們來修改配置文件，   
# cat nginx.conf
.......
http {
  include    mime.types;
  default_type application/octet-stream;
  #log_format main '$remote_addr - $remote_user [$time_local] "$request" '
  #         '$status $body_bytes_sent "$http_referer" '
  #         '"$http_user_agent" "$http_x_forwarded_for"';
  #access_log logs/access.log main;
  sendfile    on;
  #tcp_nopush   on;
  #keepalive_timeout 0;
  keepalive_timeout 65;
  #gzip on;
  proxy_cache_path /nginx/cache levels=1:2 keys_zone=first:10m inactive=24h max_size=1G;
  upstream backend {
  server 192.168.18.201 weight=1;
  }
  server {
    listen    80;
    server_name localhost;
    #charset koi8-r;
    #access_log logs/host.access.log main;
  index index.jsp index.html;
    location ~* "\.(jsp|do)$" { #當請求的是jsp或do文件時直接到tomcat上去取
      #root  html;
      #index index.html index.htm;
      #proxy_pass http://192.168.18.201/;
      #proxy_pass http://backend/;
      proxy_pass http://backend;
    }
  location = / {
    root html;
    rewrite ^/ http://192.168.18.201/index.jsp last;
  }
  location ~* "\.(jpg|jpeg|png|gif|html|css|js)$" {
    proxy_pass http://backend;
    proxy_cache first;
    proxy_cache_valid 200 24h;
    proxy_cache_valid 302 10m;
    add_header X-Cache-Status $upstream_cache_status;
  }
    #error_page 404       /404.html;
    # redirect server error pages to the static page /50x.html
    #
    error_page  500 502 503 504 /50x.html;
    location = /50x.html {
      root  html;
    }
  }
}
# /usr/local/nginx/sbin/nginx -s reload

tomcat安全規範

telnet管理端口保護（強制）	1.修改默認的8005管理端口爲不易猜想的端口（大於1024） 2.修改SHUTDOWN指令爲其餘字符串；	<Server port="8527" shutdown="dangerous">	以上配置項的配置內容只是建議配置，能夠按照服務實際狀況進行合理配置，但要求端口配置在8000~8999之間；
Ajp 鏈接端口保護(推薦)	1.修改默認的ajp 8009端口爲不易衝突的大於1024端口 2.經過iptables規則限制ajp端口訪問的權限僅爲線上機器；	<Connector port="8528" protocol="AJP/1.3" />	以上配置項的配置內容僅爲建議配置，請按照服務實際狀況進行合理配置，但要求端口配置在8000~8999之間；保護此端口的目的在於防止線下的測試流量被mod_jk轉發至線上tomcat服務器；
禁用管理端（強制）	1. 刪tomcat-users.xml，重啓tomcat會自動生成新文件 2. 刪/webapps下默認的全部目錄和文件 3. 將tomcat 應用根目錄配置爲tomcat安裝目錄之外的目錄	<Context path="" docBase="/home/work/local/tomcat_webapps" debug="0" reloadable="false" crossContext="true"/>	對於前段web模塊，Tomcat管理端屬於tomcat的高危安全隱患，一旦被攻破，黑客經過上傳web shell的方式將會直接取得服務器的控制權，後果極其嚴重；
降權啓動（強制）	1.tomcat啓動用戶權限必須爲非root權限，儘可能下降tomcat啓動用戶的目錄訪問權限 2.如需直接對外使用80端口，可經過普通帳號啓動後，配置iptables規則進行轉發		避免一旦tomcat 服務被入侵，黑客直接獲取高級用戶權限危害整個server的安全；
文件列表訪問控制（強制）	1.conf/web.xml文件中default部分listings的配置必須爲false；	<init-param> <param-name>listings</param-name> <param-value>false</param-value> </init-param>	false爲不列出目錄文件，true爲容許列出，默認爲false；
版本信息隱藏（強制）	1.修改conf/web.xml，重定向40三、404以及500等錯誤到指定的錯誤頁面； 2.也能夠經過修改應用程序目錄下的WEB-INF/web.xml下的配置進行錯誤頁面的重定向；	<error-page> <error-code>403</error-code> <location>/forbidden.jsp</location> </error-page> <error-page> <error-code>404</error-code> <location>/notfound.jsp</location> </error-page> <error-page> <error-code>500</error-code> <location>/systembusy.jsp</location> </error-page>	在配置中對一些常見錯誤進行重定向，避免當出現錯誤時tomcat默認顯示的錯誤頁面暴露服務器和版本信息；必須確保程序根目錄下的錯誤頁面已經存在；
Server header重寫（推薦）	在HTTP Connector配置中加入server的配置；	server="webserver"	當tomcat HTTP端口直接提供web服務時此配置生效，加入此配置，將會替換http 響應Server header部分的默認配置，默認是Apache-Coyote/1.1
訪問限制（可選）	經過配置，限定訪問的ip來源	<Context path="" docBase="/home/work/tomcat" debug="0" reloadable="false" crossContext="true"> <Valve className="org.apache.catalina.valves.RemoteAddrValve" allow="61.148.18.138,61.135.165." deny="...*"/> </Context>	經過配置信任ip的白名單，拒絕非白名單ip的訪問，此配置主要是針對高保密級別的系統，通常產品線不須要；
起停腳本權限回收（推薦）	去除其餘用戶對Tomcat的bin目錄下shutdown.sh、startup.sh、catalina.sh的可執行權限	chmod -R 744 tomcat/bin/*	防止其餘用戶有起停線上Tomcat的權限；
訪問日誌格式規範	開啓Tomcat默認訪問日誌中的Referer和User-Agent記錄	<Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log." suffix=".txt" pattern="%h %l %u %t %r %s %b %{Referer}i %{User-Agent}i %D" resolveHosts="false"/>	開啓Referer和User-Agent是爲了一旦出現安全問題可以更好的根據日誌進行問題排查；
1.配置部分（${ CATALINA_HOME }conf/server.xml） <Server port="8527" shutdown=" dangerous"> <!--Define a non-SSL HTTP/1.1Connector on port 8080--> <Connector port="8080" server="webserver"/> <!--Define an AJP 1.3Connector on port 8528--> <!--Define an accesslog --> <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log." suffix=".txt" pattern="%h %l %u %t %r %s %b %{Referer}i %{User-Agent}i %D" resolveHosts="false"/> <Connector port="8528" protocol="AJP/1.3"/> <Context path="" docBase="/home/work/local/tomcat_webapps" debug="0" reloadable="false" crossContext="true"/>2.配置部分（${ CATALINA_HOME }conf/web.xml或者WEB-INF/web.xml） <init-param> <param-name>listings</param-name> <param-value>false</param-value> </init-param> <error-page> <error-code>403</error-code> <location>/forbidden.jsp</location> </error-page> <error-page> <error-code>404</error-code> <location>/notfound.jsp</location> </error-page> <error-page> <error-code>500</error-code> <location>/systembusy.jsp</location> </error-page>3.刪除以下tomcat的默認目錄和默認文件 tomcat/webapps/* tomcat/conf/tomcat-user.xml4.去除其餘用戶對tomcat 起停腳本的執行權限 chmod 744–R tomcat/bin/*