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 Stack

 

configuring the heap and garbage collector

 

 

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.


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是实现

 

Web Container： JDK + Servlet+ JSP

 

商业实现：
　　WebSphere(IBM)
　　Weblogic(BEA--ORACLE)
　　Occupati
　　Oc4j
　　Glassfish
　　JBoss（核心是tomcat）

开源实现：(都需要JDK)
　　Tomcat（官方实现）
　　jetty（轻量级）
　　resin（商用收费）

 

 

 

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 defined

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

# 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.简介

查看一下默认配置文件，

1
2
3
[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中定义的每个主元素都会被创建为对象，并以某特定的层次结构将这些对象组织在一起。下面是默认配置，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
[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>
    <Listener>
    </Listener>
    <GlobalNamingResources>
    </GlobalNamingResources>
    <service>
        <connect />
        <connect />
        ...........
        <engine>
            <host>
                <context />
                .......
            <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组件

如上面示例文件中定义的：

1
<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连接器：

1
2
3
<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连接器：

1
2
3
4
<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容器中用于接收请求并进行相应处理的主机或虚拟主机，如前面默认配置文件中定义：

1
2
3
4
<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；

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

1
2
3
4
5
6
7
8
9
10
<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>

主机别名定义：

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

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

(6).Context组件

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

1
2
3
4
5
6
7
8
9
10
11
<!-- 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的配置：

1
2
3
4
5
6
7
8
9
10
<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：

1
2
3
4
<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/  根据提示进行安装






二、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，重定向403、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.xml
4.去除其他用户对tomcat 起停脚本的执行权限
    chmod 744–R tomcat/bin/*		




































 






            

            
posted @ 
2017-05-29 12:59 
黑色月牙 
阅读(773) 
评论(0) 
编辑 
收藏 
举报