Tomcat

Tomcat

自 2017 年 11 月编程语言排行榜 Java 占比 13%，高居榜首，Tomcat 也一度成为 Java开发人员的首选。其开源、占用系统资源少、跨平台等特性被深受喜爱。本章主要学习如何部署 Tomcat 服务，根据生产环境实现多个虚拟主机的配置，最后的重点是进行压测，根据压测结果如何优化 Tomcat 服务及常见的内存溢出如何处理。

一、Tomcat简介

Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。对于一个初学者来说，可以这样认为，当在一台机器上配置好Apache 服务器，可利用它响应HTML（标准通用标记语言下的一个应用）页面的访问请求。际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的诀窍是，当配置正确时，Apache 为HTML页面服务，而Tomcat 实际上运行JSP 页面和Servlet。另外，Tomcat和IIS等Web服务器一样，具有处理HTML页面的功能，另外它还是一个Servlet和JSP容器，独立的Servlet容器是Tomcat的默认模式。不过，Tomcat处理静态HTML的能力不如Apache服务器。

官方文档

https://tomcat.apache.org/

1、web技术

1.1 http协议和B/S（Browser/Server）结构

操作系统有进程子系统，使用多进程就可以充分利用硬件资源。进程中可以多个线程，每一个线程可以被CPU调度执行，这样就可以让程序并行的执行。这样一台主机就可以作为—个服务器为多个客户端提供计算服务。

客户端和服务端往往处在不同的物理主机上，它们分属不同的进程，这些进程间需要通信。跨主机的进程间通信需要使用网络编程。最常见的网络编程接口是socket。

Socket称为套接字，本意是插座。也就是说网络通讯需要两端，如果一端被动的接收另一端请求并提供计算和数据的称为服务器端，另一端往往只是发起计算或数据请求，称为客户端。

这种编程模式称为Client/Server编程模式，简称C/S编程，开发的程序也称为C.S程序。CIS编程往往使用传输层协议(TCPIUDP)，较为底层，比如:QQ，迅雷,云音乐,云盘, foxmail， xshell等。

1990年HTTP协议和浏览器诞生。在应用层使用文本跨网络在不同进程间传输数据，最后在浏览器中将服务器惴返回的HTML渲染出来。由此，诞生了网页开发。

网页是存储在WEB服务器端的文本文件，浏览器发起HTTP请求后，到达WNEB服务程序后，服务程序根据URL读取对应的HTML文件，并封装成HTP响应报文返回给浏览器端。

起初网页开发主要指的是HTML、CSS等文件制作，目的就是显示文字或图片，通过超级链接跳转到另一个HTML并显示其内容。

后来，网景公司意识到让网页动起来很重要，傍着SUN的ava的名气发布了JavaScript语言，可以在浏览器中使用5引攀执行的脚本语言，可以让网页元素动态变化。网页动起来了。

为了让网页动起来，微软使用ActiveX技术、SUN的Applet都可以在浏览器中执行代码，但都有安全性问题。能不能直接把内容直接在WEB服务器端组织成HTML，然后把HTML返回给浏览器渲染呢?

最早出现了CGl (Common Gateway Interface)通用网关接口，通过浏览器中输入URL直接映射到一个服务器端的脚本程序执行，这个脚本可以查询数据库并返回结果给浏览器端。这种将用户请求使用程序动态生成的技术，称为动态网页技术。先后出现了ASP、PHP、JSP等技术，这些技术的使用不同语言编写的程序都运行在服务器端，所以称为WEB后端编程。有一部分程序员还是要编写HTML、CSS、JavaScript，这些代码运行在浏览器端，称为WEB前端编程。合起来称为Browser/Server编程，即B/S编程。

1.2前端三大核心技术

1.2.1 HTML

1.2.2 css

1.2.3 javascript

Javascript简称S，是一种动态的弱类型脚本解释性语言，和HTML、CSS并称三大WEB核心技术，得到了几乎主流浏览器支持。

2008年后随着chrome浏览器的V8引擎发布。

V8JS引|擎不是解释执行，而是本地编译，在V8B引擎做了很多优化，JS程序在其上运行堪比本地二进制程序。V8引擎使用C++开发，可以嵌入到任何C++程序中。基于V8引擎，2009年基于服务器javascript的运行环境Node.js诞生，创建了第一版npm (Node js包管理嚣和开源库生态系统)提供了大显的库供程序员使用。从此，便可以在服务器端真正大规模使用jJvaScript编程了。也就是说JavaScript 也可以真正称为服务器端编程语言了，成为目前唯一的前，后端通用的语言。

同步

交互式网页，用户提交了请求，就是想看到查询的结果。服务器响应到来后是一个全新的页面内容，哪怕URL不变，整个网页都需要重新渲染。例如，用户填写注册信息，只是2次密码不一致，提交后，整个注册页面重新刷新，所有填写项目重新填写(当然有办法让用户减少重填)。这种交互非常不友好。从代价的角度看，就是为了注册的一点点信息，结果返回了整个网页内容，不但浪费了网络带宽，还需要浏览器重新渲染网页，太浪费资源了，影响了用户体验和感受。上面这些请求的过程，就是同步过程，用户发起请求，页面整个刷新，直到服务器端响应的数据到来并重新渲染。

异步

传统的网页如果需要更新内容，必需重数整个网页面。Ajax的出现，改变这一切，同时极大的促进了Javascript的发展。Ajax即"Asynchronous Javascript AndXML”(异步JavaScript和XML)，是指一种创建交互式、快速动态网页应用的网页开发技术，最早起源于1998年微软的Outook Web Access开发团队。Ajax通过在后台与服务器进行少量数据交换，可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。Javascript通过调用浏览器内置的WEB API中的XMLHttpRequest对象实现Ajax技术。早期Aijax结合数据格式XML，目前更多的使用)SON。利用AAX可实现前后端开发的彻底分离，改变了传统的开发模式。

2、java基础

2.1 web架构

2.1.1 web资源和访问

PC端或移动端浏览器访问
从静态服务器请求HTML、CSS、JS等文件发送到浏览器端，浏览器端接收后渲染在浏览器上从图片服务器请求图片资源显示
从业务服务器访问动态内容，动态内容是请求后有后台服务访问数据库后得到的，最终返回到浏览器端

手机 App访问
内置了HTML和]S文件，不需要从静态WEB服务器下载JS或HTML。为的就是减少文件的发送，现代前端开发使用的S文件太多或太大了有必要就从图片服务器请求图片，从业务服务器请求动态数据
客户需求多样，更多的内容还是需要由业务服务器提供，业务服务器往往都是由一组服务器组成。

2.1.2 后台应用架构

2.1.2.1 单体应用架构

• 传统架构(单机系统)。一个项目一个工程：比如商品、订单、支付、库存、登录、注册等等，统一部署，一个进程

• all in one的架构方式，把所有的功能单元放在一 个应用里。然后把整个应用部署到一台服务器上。如果负载能力不行，将整个应用进行水平复制，进行扩展，然后通过负载均衡实现访问。

• Java实现: JSP、 Servlet, 打包成一个jar. war部署

• 优点：易于开发和测试，也十分方便部署。当需要扩展时，只需要将war复制多份，然后放到多个服务器上，再做个负载均衡就可以了。

• 缺点：如果某个功能模块出问题，有可能全站不可访问，修改Bug后、某模块功能修改或升级后，需要停掉整个服务，重新整体重新打包、部署这个应用war包，功能模块相互之间耦合度高，相互影响，不适合当今互联网业务功能的快速迭代。特别是对于一个大型应用，我们不可能把所有内容都放在一个应用里面，我们如何维护、如何分工合作都是问题。如果项目庞大，管理难度大

• web应用服务器：开源的tomcat. jetty. glassfish。 商用的有weblogic、websphere. Jboss

2.1.2.2 微服务

https://www.martinfowler.com/microservices/

属于SOA (Service Oriented Architecture)的子集
微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底去掉耦合，每一个微服务提供单个业务功能，一个服务只做一件事。每个服务都围绕着具体业务进行构建，并且能够被独立地部署到生产环境、类生产环境等。从技术角度讲就是一种小而独立的处理过程，类似与进程的概念，能够自行单独启动或销毁
微服务架构（分布式系统)，各个模块/服务，各自独立出来，"让专业的人干专业的事”，独立部署。分布式系统中，不同的服务可以使用各自独立的数据库。·服务之间采用轻量级的通信机制(通常是基于HTTP的RESTful API)。

微服务设计的思想改变了原有的企业研发团队组织架构。传统的研发组织架构是水平架构，前端、后端、DBA、测试分别有自己对应的团队，属于水平团队组织架构。而微服务的设计思想对团队的划分有着一定的影响，使得团队组织架构的划分更倾向于垂直架构，比如用户业务是一个团队来负责，支付业务是一个团队来负责。但实际上在企业中并不会把团队组织架构拆分得这么绝对，垂直架构只是一种理想的架构。微服务的实现框架有多种，不同的应用架构，部署方式也有不同

2.1.2.3 单体架构和微服务比较

2.1.2.4 微服务的优缺点

微服务优点

• 每个服务足够内聚，足够小，代码容易理解。这样能聚焦一个只当的业务功能或业务需求。
• 开发简单、开发效率提高，一个服务可能就是专业的只干一件事，微服务能够被小团队单独开发，这个小团队可以是2到5人的开发人员组成·微服务是松耦合的，是有功能意义的服务，无论是在开发阶段或部署阶段都是独立的。
• 微服务能使用不同的语言开发
• 易于和第三方集成，微服务运行容易且灵活的方式集成自动部署，通过持续集成工具，如: Jenkins、Hudson、Bamboo·微服务易于被一个开发人员理解、修改和维护，这样小团队能够更关注自己的工作成果，无需通过合作才能体现价值。微服务允许你利用融合最新技术。微服务只是业务逻辑的代码，不会和HTML/CSS或其他界面组件混合，即前后端分离·每个微服务都有自己的存储能力，可以有自己的数据库，也可以有统一数据库。

微服务缺点

• 微服务把原有的一个项目拆分成多个独立工程，增加了开发、测试、运维、监控等的复杂度
• 微服务架构需要保证不同服务之间的数据一致性，引入了分布式事务和异步补偿机制，为设计和开发带来一定挑战·开发人员和运维需要处理分布式系统的复杂性，需要更强的技术能力
• 微服务适用于复杂的大系统，对于小型应用使用微服务，进行盲目的拆分只会增加其维护和开发成本

2.2 java

2.2.1 Java历史

Java原指的是印度尼西亚的爪哇岛，人口众多，盛产咖啡、橡胶等。

Java语言最早是在1991年开始设计的，最初叫Oak项目，它初衷是跑在不同机顶盒设备中的。

1993年网景公司成立。Oak项目组很快他们发现了浏览器和动态网页技术这个巨大的市场，转向WEB方向。并首先发布了可以让网页动起来的Applet技术（浏览器中嵌入运行Java字节码的技术）。

在1995年，一杯爪哇岛咖啡成就了Java这个名字。

Sun公司第一个Java公开版本1.0发布于1996年。口号是"一次编写，到处运行"(Write once，Run anywhere)，跨平台运行。

1999年，SUN公司发布了第二代Java平台(Java2)。

2009年4月20日，Oracle甲骨文公司宣布将以每股9.50美元，总计74亿美金收购SUN（计算机系统）公司。2010年1月成功收购

2010年，Java创始人之一的 James Gosling 离开了Oracle，去了Google。

2010年8月13日，Oracle在加利福尼亚地方法院起诉Google侵犯版权和专利权。Oracle声称Google侵犯了Java 37个API和部分专利。地方法院的陪审团认为未侵犯专利，且API无版权。

2016年5月26日，地方法院二审陪审团认定未侵犯版权，对37个JAVA API的重新实现受到合理使用的保护。

2017年Oracle上诉美国联邦巡回上诉法院，2018年3月27日判决Oracle胜诉，Google应赔偿近90亿美金。

2019年1月Google想让美国最高法院撤销联邦法院裁决。谷歌表示裁决是"对软件业的毁灭性一击"。现任特朗普政府支持Oracle公司，但微软、Mozilla、 红帽支持Google。目前案件已经受理，但由于疫情推迟。有更多的企业和组织加入进来，包括IBM、计算机和通信协会、互联网协会、超过150名学者和教授。此案如果Oracle胜诉，将在美国形成判例，将深远广泛影响软件业。例如: POSIX接口， 是商用系统UNIX的兼容接口规范。

2.2.2 java 组成

Java包含下面部分

• 语言、语法规范。关键字,如: if、for、class等

• 源代码source code

• 依赖库，标准库(基础).I第三方库(针对某些应用)。底层代码太难使用且开发效率低，封装成现成的库

• JVM虚拟机。将源代码编译为中间码即字节码后,再运行在JVM之上

由于各种操作系统ABl不一样，采用编译方式，需要为不同操作系统编译成相应格式的二进制程序才能运行。

2.2.3 实现动态网页功能

2.2.3.1 servelt

• 本质是一段java程序
• 在Servlet中最大的问题是，HTML输出和java代码混在一起，如果网页布局要调整，Java源代码就需要随之进行调整，对于开发人员来说就是噩梦。

import java.io.*;
import javax.servlet . * ;
import javax. servlet . http .*;
public class Helloword extends HttpServlet {
private string message;
public void init( )throws Serv1etException
{
message = "He1lo wor1d";
}
public void doGet(HttpservletRequest request,
                  HttpServletResponse response)
         throws servletException，IOException
{
response.setContentType("text/htm1");//响应报文内容类型

printwriter out = response.getwriter(; //构建响应报文内容
out.print1n("<h1>" + message + "</h1>");
out.print1n("<p><a href=http://www.kgc.com>课工场</a>欢迎你</p>");
}
public void destroyo{
    {
}
}

2.2.3.2 jsp

JSP本质是提供一个HTML模板，也就是在网页中预留以后填充的空，后续将Java程序运行生成的数据对HTML进行填空就可以了。如果网页布局需要调整，JAVA源代码不需要很大的调整

<%@page language="java" contentType="text/htm1; charset=UTF-8"
    pageEncoding="UTF-8"%>
<! DOCTYPE html>
I<htm1>
<head>
    <meta charset="utf-8">
    <title>jsp例子</title></head>
<body>
本行后面的内容是服务器端动态生成字符串，最后拼接在一起
<%
out. print1n(""你的IP地址" + request.getRemoteAddr(C);
%>
</body></htm1>

优点：架构简单，比较适合小型项目开发

缺点：JSP职责不单一，职责过重，不便于维护

2.2.4 jdk

2.2.4.1 JDK 和 JRE

①、JDK 和 JRE 关系

• Java SE APl: Java 基础类库开发接口
• JRE: Java Runtime Environment缩写，指Java运行时环境，包含JVM +Java核心类库
• JDK: Java Development Kit，即Java语言的软件开发工具包JDK协议基于JRL(JavaResearch License)协议

②、JVM 的各种版本

• SUN HotSpot
• IBM J9VM
• BEA JRockit

参考链接

https://en.wikipedia.org/wiki/List_of_Java_virtual_machines

https://en.wikipedia.org/wiki/Comparison_of_Java_virtual_machines

③、Oracle JDK 版本

JDK也就是常说的J2SE，在1999年，正式发布了Java第二代平台，发布了三个版本：

• J2SE：标准版，适用于桌面平台
• J2EE：企业版，java在企业级开发所有规范的总和，共有13个大的规范,Servlet、Jsp都包含在JavaEE规范中
• J2ME：微型版，适用于移动、无线、机顶盒等设备环境

2005年，Java的版本又更名为JavaSE、JavaEE、JavaME

JDK7、JDK8、JDK11是LTS（Long Term Support）

2.2.4.2 OpenJDK

①、OpenJDK 介绍

• OpenJDK是Sun公司采用GPL v2协议发布的JDK开源版本，于2009年正式发布。
• 相对来说，Oracle jDK具有更好的响应能力和JVM性能，更加稳定。

官方网站

https://openjdk.java.net/projects/jdk6/

②、安装 openjdk

在CentOS中，可以使用 yum 仓库安装 openjdk

yum list "*jdk*"
#查看可以安装哪些版本

yum -y install java-1.8.0-openjdk.x86_64 java-1.8.0-openjdk-devel
#安装jdk环境

java -version
#查看版本（centos中，默认的是openjdk）
openjdk version "1.8.0_402"
OpenJDK Runtime Environment (build 1.8.0_402-b06)
OpenJDK 64-Bit Server VM (build 25.402-b06, mixed mode)

2.2.4.3 安装oracle 官方 JDK

官方下载链接

#注意需要注册登录后,才能下载JDK
https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html

①、**使用rpm安装 Oracle JDK **

#需要登录下载：（或将需要的软件包上传）https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html

yum install -y jdk-8u291-linux-x64.rpm
#安装软件包

#修改环境变量
vim /etc/profile.d/jdk.sh
export JAVA_HOME=/usr/java/default
export PATH=$JAVA_HOME/bin:$PATH
#以下两项非必须项
export JRE_HOME=$JAVA_HOME/jre   
export CLASSPATH=$JAVA_HOME/lib/:$JRE_HOME/lib/

. /etc/profile.d/jdk.sh
#运行

java -version
#查看版本

②、使用二进制文件安装 Oracle JDK

#将需要的二进制包上传

tar xf jdk-8u291-linux-x64.tar.gz -C /usr/local
#将二进制包解压到/usr/local目录

cd /usr/local/
#切换目录

ln -s jdk1.8.0_291/ jdk
#做软连接

#修改环境变量
vim /etc/profile.d/jdk.sh
export JAVA_HOME=/usr/local/jdk
export PATH=$JAVA_HOME/bin:$PATH
export JRE_HOME=$JAVA_HOME/jre   
export CLASSPATH=$JAVA_HOME/lib/:$JRE_HOME/lib/

. /etc/profile.d/jdk.sh
#运行

java -version
#查看版本

二、Tomcat 基础功能

1、tomcat介绍

Tomcat服务器是一个免费的开放源代码的Web应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，Tomcat具有处理HTML页面的功能，它还是一个Servlet和JSP容器

Tomcat仅仅实现了Java EE规范中与Servlet、JSP相关的类库，是JavaEE不完整实现。

官网

 http://tomcat.apache.org/

官网文档

 https://tomcat.apache.org/tomcat-8.5-doc/index.html

帮助文档

https://cwiki.apache.org/confluence/display/tomcat/

https://cwiki.apache.org/confluence/display/tomcat/FAQ

2、安装 tomcat

2.1 基于CentOS7 包安装 Tomcat

yum list tomcat*

2.2 二进制安装 Tomcat

• 推荐从Apache官网下载二进制tomcat包进行安装

注意:安装tomcat 前必须先部署JDK

官方和镜像站点下载

https://tomcat.apache.org/download-80.cgi
https://mirrors.tuna.tsinghua.edu.cn/apache/tomcat/

二进制安装tomcat

##安装tomcat前必须先部署JDK

1、部署jdk
#将需要的jdk二进制包上传

tar xf jdk-8u291-linux-x64.tar.gz -C /usr/local
#将二进制包解压到/usr/local目录

cd /usr/local/
#切换目录

ln -s jdk1.8.0_291/ jdk
#做软连接

#修改环境变量
vim /etc/profile.d/jdk.sh
export JAVA_HOME=/usr/local/jdk
export PATH=$JAVA_HOME/bin:$PATH
export JRE_HOME=$JAVA_HOME/jre   
export CLASSPATH=$JAVA_HOME/lib/:$JRE_HOME/lib/

. /etc/profile.d/jdk.sh
#运行

java -version
#查看版本

2、安装tomcat
#将需要的tomcat二进制包上传

tar xf apache-tomcat-9.0.16.tar.gz 
#解压到指定目录

cp -r apache-tomcat-9.0.16 /usr/local/
#复制

cd /usr/local
#切换目录

ln -s apache-tomcat-9.0.16/ tomcat
#做软连接

/usr/local/tomcat/bin/startup.sh
#启动tomcat
Using CATALINA_BASE:   /usr/local/tomcat
Using CATALINA_HOME:   /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME:        /usr/local/jdk/jre
Using CLASSPATH:       /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
Tomcat started.

使用浏览器访问：192.168.10.11:8080

/usr/local/tomcat/bin/shutdown.sh
#关闭tomcat

useradd -M -s /sbin/nologin tomcat
#新建用户

chown tomcat:tomcat /usr/local/tomcat/ -R
#修改属主和属组

vim /usr/lib/systemd/system/tomcat.service
[Unit]
Description=Tomcat
After=syslog.target network.target

[Service]
Type=forking
ExecStart=/usr/local/tomcat/bin/startup.sh
ExecStop=/usr/local/tomcat/bin/shutdown.sh
RestartSec=3
PrivateTmp=true
User=tomcat
Group=tomcat

[Install]
WantedBy=multi-user.target
   
systemctl daemon-reload
#重新加载配置

systemctl start tomcat
#开启服务

ss -ntap |grep 8080
#查看开启的端口号


pstree -p |grep tomcat

ps aux |grep tomcat

pstree -p |grep java

#因为tomcat程序是使用java运行的，所以并不能直接过滤到tomcat，只能看到Java进程

• 打开浏览器访问：192.168.10.11:8080，正常可以看到以下界面

tomcat 和 catalina 关系

Tomcat的servlet容器在4.X版本中被Craig McClanahan(Apache Struts项目的创始人,也是Tomcat 
的 Catalina 的架构师)重新设计为Catalina.即Catalina就是servlet容器。

Tomcat的核心分为3个部分: 
（1）Web容器:处理静态页面
（2）JSP容器:把jsp页面翻译成一般的 servlet
（3）catalina: 是一个servlet容器,用于处理servlet

三、配置文件介绍及核心组件

1、配置文件

注意：配置文件对于大小写敏感

1.1 安装目录/usr/local/tomcat文件

目录名字	功能
bin	存放启动和关闭 Tomcat 的脚本文件，比较常用的是 catalina.sh、startup.sh、shutdown.sh 三个文件
conf	存放 Tomcat 服务器的各种配置文件，比较常用的是 server.xml、context.xml、tomcat-users.xml、web.xml 四个文件。
lib	存放 Tomcat 服务器的 jar 包，一般不作任何改动，除非连接第三方服务，比如 redis，那就需要添加相对应的 jar 包
logs	存放 Tomcat 日志
temp	存放 Tomcat 运行时产生的文件
webapps	存放项目资源的目录
work	Tomcat 工作目录，一般清除 Tomcat 缓存的时候会使用到（升级版本时注意要删除里面的缓存）

1.2 /usr/local/tomcat/conf子目录

文件名	说明
server.xml	主配置文件 全局生效
web.xml	每个webapp只有“部署"后才能被访问,它的部署方式通常由web.xml进行定义,其存放位置为WEB-INF/目录中;此文件为所有的webapps提供默认部署相关的配置,每个web应用也可以使用专用配置文件,来覆盖全局文件
context.xml	用于定义所有web应用均需加载的Context配置,此文件为所有的webapps提供默认配置,每个web应用也可以使用自已专用的配置,它通常由专用的配置文件context.xml来定义,其存放位置为WEB-INF/目录中,覆盖全局的文件
tomcat-users.xml	用户认证的账号和密码文件
catalina.policy	当使用security选项启动omcat时,用于为tomcat设置安全策略
catalina.properties	Tomcat环境变量的配置,用于设定类加载器路径，以及一些与JVM调优相关参数
logging.properties	Tomcat日志系统相关的配置，可以修改日志级别和日志路径等

1.3 日志文件与临时、缓存文件

catalina.2024-03-04.log
#tomcat服务日志

catalina.out
#tomcat错误服务日志

host-manager.2024-03-04.log
#host manager管理日志

localhost.2024-03-04.log
#默认主机日志

localhost_access_log.2024-03-04.txt
#默认主机访问日志

manager.2024-03-04.log
#manager 管理日志

2、访问目录

/usr/local/tomcat/webapps/ROOT
#访问目录文件位置

/usr/local/tomcat/webapps/ROOT/index.jsp
#访问的页面

3、组件

3.1 组件分层和分类

3.1.1 顶级组件

Server，代表整个Tomcat容器，一台主机可以启动多tomcat 实例 ，需要确保端口不要产生冲突

3.1.2 服务类组件

Service，实现组织Engine和Connector，建立两者之间关联关系, service 里面只能包含一个Engine

3.1.3 连接器组件

Connector，有HTTP（默认端口8080/tcp）、HTTPS（默认端口8443/tcp）、AJP（默认端口8009/tcp）协议的连接器，AJP（Apache Jserv protocol）是一种基于TCP的二进制通讯协议。

3.1.4 容器类

Engine、Host（虚拟主机）、Context(上下文件,解决路径映射)都是容器类组件，可以嵌入其它组件，内部配置如何运行应用程序。

3.1.5 内嵌类

可以内嵌到其他组件内，valve、logger、realm、loader、manager等。以logger举例，在不同容器组件内分别定义。

3.1.6 集群类组件

listener、cluster

过程：

• 首先开启 tomcat进程， 会有server产生；

• 然后产生 一个service管理组件管理所有其他组件的；

• 用户发送请求httpd请求过来；

• connector连接器（默认监听）接收到此请求， 会转交给engine（引擎）；

• engine（引擎）会处理请求，遍历 host（虚拟主机）会交给客户访问的host， 如果找不到交给默认的host会根据 上下文 context（上下文）映射关系 去找相对应的文件；

• 找到文件后，交给JSP生成代码，再交给servlet生成html；

• 原路返回反馈给用户。

名称	说明
server	服务器，Tomcat运行的进程实例，一个Server中可以有多个service，但通常就一个
service	服务，用来组织Engine（引擎）和Connector（连接器，端口）的对应关系，一个service中只有一个Engine
connector	连接器，负责客户端的HTTP、HTTPS、AJP等协议连接。一个Connector只属于某一个Engine
Engine	即引擎，用来响应并处理用户请求。一个Engine上可以绑定多个Connector
Host	即虚拟主机,可以实现多虚拟主机,例如使用不同的主机头区分
Context	应用的上下文，配置特定url路径映射和目录的映射关系: url => directory

3.2 核心组件

• Tomcat启动一个Server进程。可以启动多个Server，即tomcat的多实例, 但一般只启动一个

• 创建一个Service提供服务。可以创建多个Service，但一般也只创建一个

  • 每个Service中，是Engine和其连接器Connector的关联配置

• 可以为这个Service提供多个连接器Connector，这些Connector使用了不同的协议，绑定了不同的端口。其作用就是处理来自客户端的不同的连接请求或响应

• Service 内部还定义了Engine，引擎才是真正的处理请求的入口，其内部定义多个虚拟主机Host

  • Engine对请求头做了分析，将请求发送给相应的虚拟主机
  • 如果没有匹配，数据就发往Engine上的defaultHost缺省虚拟主机
  • Engine上的缺省虚拟主机可以修改

• Host 定义虚拟主机，虚拟主机有name名称，通过名称匹配

• Context 定义应用程序单独的路径映射和配置

相关配置文件

vim  /usr/local/tomcat/conf/server.xml

<?xml version="1.0" encoding="UTF-8"?>
<Server port="8005" shutdown="SHUTDOWN">
  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />

<Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />

  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />

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

<Service name="Catalina"> 

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

<Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
  
 <Engine name="Catalina" defaultHost="localhost">
<Realm className="org.apache.catalina.realm.LockOutRealm">
 <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
               resourceName="UserDatabase"/>
      </Realm>

      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">
 <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>

    
<>：表示组件开始
</>表示组件结尾
<!--  --!>表示注释的内容

3.3 tomcat 处理请求过程

假设来自客户的请求为: http://localhost:8080/test/index.jsp

• 浏览器端的请求被发送到服务端端口8080，Tomcat进程监听在此端口上。通过侦听的HTTP/1.1Connector获得此请求。

• Connector把该请求交给它所在的Service的Engine来处理，并等待Engine的响应

• Engine获得请求192.168.91.100:8080/test/index.jsp，遍历它所有虚拟主机Host

• Engine匹配到名为localhost的Host。如果匹配不到,就把请求交给该Engine中的defaultHost处理. localhost Host获得请求/test/index.jsp，匹配它所拥有的所有Context

• Host匹配到路径为/test的Context

• path=/test的Context获得请求index.jsp，在它的mapping table中寻找对应的servlet

• Context匹配到URLPATTERN为*.jsp的Sservlet，对应于]spServlet类构造HtpServletRequest对象和HttpServletResponse对象，作为参数调用)spSer
  let的doGet或doPost方法。

• Context把执行完了之后的HttpServletResponse对象返回给Host

• Host把HttpServletResponse对象返回给Engine

• Engine把HttpServletResponse对象返回给Connector

• Connector把HttpServletResponse对象返回给浏览器端

#接收请求
 
'当客户端（通常是Web浏览器）向Tomcat服务器发送一个HTTP请求时，请求首先被监听在特定端口上的Connector组件接收。例如，对于默认配置，HTTP Connector通常监听8080端口'
 
#解析请求
'Connector接收到请求后，会根据HTTP协议规范对请求进行解析，提取出请求方法（GET、POST等）、请求URI、HTTP头信息以及可能存在的请求体内容'
 
#路由请求到适当的Context：
'解析后的请求将被传递给Engine容器，Engine通过匹配请求的Host头或IP地址找到对应的虚拟主机（Host）。Host接着根据请求URI找到关联的Web应用程序Context，也就是WAR文件解压后部署的应用目录。'
 
#查找并执行Servlet
'Context容器负责查找请求URI映射到的Servlet，并实例化或重用该Servlet。如果请求的URL与某个Servlet的URL映射规则相匹配，则调用Servlet的service()方法来处理请求'
 
#处理请求
'在Servlet内部，根据请求的方法和请求参数，调用相应的doGet()、doPost()等方法处理请求数据，并生成响应结果。'
 
#创建响应
'Servlet处理完成后，返回一个HttpServletResponse对象，其中包含了状态码、响应头和响应体内容（如HTML页面、JSON数据或其他格式的内容）。'
 
#写回响应
'Context将Servlet生成的响应传递给Host，再由Host传递给Engine，最终由Engine中的Connector将响应数据封装成HTTP响应报文并通过网络发送回客户端。'
 
#清理资源：
'在整个处理过程中，Tomcat还负责管理连接、线程池以及其他系统资源，确保请求处理完毕后释放相关资源以供后续请求使用'
 
#生命周期事件通知：
'Tomcat在应用启动、停止、上下文初始化、销毁等阶段还会触发相应的生命周期事件，以便开发者能够插入自定义的初始化逻辑或资源清理操作。'

 Tomcat 由一系列的组件构成，其中核心的组件有三个：
1、Web 容器：完成 Web 服务器的功能。（https请求）
2、Servlet 容器：名字为 catalina，用于处理 Servlet 代码。(具体的任务)
3、JSP 容器：用于将 JSP 动态网页翻译成 Servlet 代码。

主页文件的优先级

• index.html
• index.htm
• index.jsp

vim /usr/local/tomcat/conf/web.xml
<welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

</web-app>

4、打包jar包

• .war：WebApp打包,类zip格式文件,通常包括一个应用的所有资源,比如 jsp,html,配置文件等

• .jar：EJB类文件的打包压缩类zip格式文件，,包括很多的class文件, 网景公司发明

• .rar：资源适配器类打包文件，目前已不常用

• .ear：企业级WebApp打包，目前已不常用

传统应用开发测试后，通常打包为war格式，这种文件部署到Tomcat的webapps目录下，并默认会自动

4.1 打包jar实际操作

cd /mnt
#切换目录

echo test.jsp > test.jsp

echo test.html > test.html

#查看生成的文件
ls
test.html  test.jsp

jar cvf /mnt/app1.war *
#打包

cd /usr/local/tomcat/webapps/
#切换目录

mkdir app1
#新建文件夹

cp /mnt/app1.war .
#复制之前的压缩包到当前目录

ls
#查看当前目录，压缩包会自动解压

下线只要删除war包直接自动删除

4.2 自建博客

cd /data
#切换目录

ls
#上传需要的软件包

systemctl status tomcat
#查看tomcat状态开启

cp jpress-v3.2.1.war /usr/local/tomcat/webapps/
#将需要的软件包复制到指定目录

cd /usr/local/tomcat/webapps/
#切换目录

ln -s jpress-v3.2.1 jpress
#做软连接

#多行重定向，创建一个新的yum仓库配置文件
cat >/etc/yum.repos.d/mysql.repo <<EOF
[mysql57-community]
name=MySQL 5.7 Community Server
baseurl=http://repo.mysql.com/yum/mysql-5.7-community/el/7/x86_64/
enabled=1
gpgcheck=0
EOF

yum install -y mysql-community-server
#安装

systemctl start mysqld
#开启mysqld服务

ss -ntap |grep 3306
#查看进程号

grep password /var/log/mysqld.log
#查看mysqld临时密码

mysql -u root -p
#登录mysql

set global validate_password_policy=0;
set global validate_password_length=1;
#修改密码策略
mysql> alter user root@'localhost' identified by 'abc123';
#重新设定密码

mysql -u root -pabc123
#使用修改后的密码登录

CREATE DATABASE blog;
#创建一个blog数据库
GRANT all ON blog.* TO 'bloguser'@'%' IDENTIFIED BY 'admin123';
#为bloguser用户设置密码，分配权限
GRANT all ON blog.* TO 'bloguser'@'localhost' IDENTIFIED BY 'admin123';
#为bloguser用户设置密码，分配权限
flush privileges;
#刷新

quit
#退出

5、状态页

5.1 server status 和 manger app 访问

5.1.1 默认的管理页面被禁用

• server status 状态页
• manger app 管理项目
• host manger 配置虚拟主机的设置

5.1.2 开启状态页（只能本地访问)

修改**/usr/local/tomcat/conf/tomcat-users.xml**配置文件（修改后只能本机登录访问）

cd /usr/local/tomcat/conf
#切换目录

#修改配置内容
vim tomcat-users.xml
<role rolename="manager-gui"/>
<user username="tomcat" password="tomcat" roles="manager-gui"/>
#添加上面两行内容，指定用户和密码

systemctl restart tomcat
#重启服务

127.0.0.1:8080
#只能使用本机登录访问

5.1.3 开启允许远程访问状态页

修改**/usr/local/tomcat/webapps/manager/META-INF/context.xml**配置文件（修改完成后，可以远程登录访问）

cd /usr/local/tomcat/webapps/manager/META-INF
#切换目录

#修改配置文件
vim context.xml
allow="127\.\d+\.\d+\.\d+|::1|0:0:0:0:0:0:0:1|192\.168\.10\.\d+" />
#添加允许访问的ip地址（|192\.168\.10\.\d+）

systemctl restart tomcat
#重启服务

##验证
192.168.10.11:8080
#使用主机远程登录访问，输入用户名和密码后访问状态页

• 服务管理页面

5.2 host manger

• 配置虚拟主机的设置

cd /usr/local/tomcat/conf
#切换目录

#修改配置文件
vim tomcat-users.xml
<role rolename="admin-gui"/>
<user username="tomcat" password="tomcat" roles="manager-gui,admin-gui"/>
#添加配置内容

systemctl restart tomcat
#重启服务

cd /usr/local/tomcat/webapps/host-manager/META-INF
#切换目录

#修改配置文件
vim context.xml
allow="127\.\d+\.\d+\.\d+|::1|0:0:0:0:0:0:0:1|192\.168\.10\.\d+" />
#添加允许访问的ip地址（|192\.168\.10\.\d+）

systemctl restart mysql
#重启服务


##验证
192.168.10.11:8080
#使用主机远程登录访问，输入用户名和密码后访问host manger

6、常见配置详解

6.1 端口8005/tcp安全配置管理

在conf/server.xml 有以下内容

<?xml version="1.0" encoding="UTF-8"?>
<Server port="8005" shutdown="SHUTDOWN">
  <Service name="Catalina">
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
    <Engine name="Catalina" defaultHost="localhost">
      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">
      </Host>
    </Engine>
  </Service>
</Server>

8005是Tomcat的管理端口，默认监听在127.0.0.1上。无需验证就可发送SHUTDOWN (大小写敏感)这个字符串，tomcat接收到后就会关闭此Server。

[root@centos7 ~]#telnet 127.0.0.1 8005
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
SHUTDOWN #执行命令关闭tomcat
Connection closed by foreign host.
[root@centos7 ~]#ss -ntl
State       Recv-Q       Send-Q                 Local Address:Port             
    Peer Address:Port       
LISTEN       0             128                          0.0.0.0:22               
         0.0.0.0:*         
LISTEN       0             128                             [::]:22

此管理功能建议禁用，可将SHUTDOWN改为一串猜不出的字符串实现或者port修改成 0,会使用随机端口如:36913

port设为-1等无效端口,将关闭此功能此行不能被注释,否则无法启动tomcat服务

示例

<Server port="8005" shutdown="44ba3c71d57f494992641b258b965f28">

6.2 tomcat 端口号

• 8080： 默认接收 http 请求的端口
• 8005： 安全端口，可以关闭tomcat
• 8009： apache 和 tomcat 联动 AJP 协议

6.3 虚拟主机配置

可能有时候公司会有多个项目需要运行，那么肯定不可能是一台服务器上运行多个Tomcat 服务，这样会消耗太多的系统资源。此时，就需要使用到 Tomcat 虚拟主机。

#创建虚拟主机前,必须先创建相关目录,否则创建虚拟机不成功
mkdir /data/web{1,2,3}/ROOT/ -p
#创建文件夹

echo  web1 www.a.com > /data/web1/ROOT/index.html
echo  web2 www.b.com > /data/web2/ROOT/index.html
echo  web3 www.c.com > /data/web3/ROOT/index.html
#创建三个页面

#修改配置文件
vim /usr/local/tomcat/conf/server.xml
 <Host name="www.a.com"  appBase="/data/web1"
            unpackWARs="true" autoDeploy="true">
            </Host>
 
      <Host name="www.b.com"  appBase="/data/web2"
            unpackWARs="true" autoDeploy="true">
            </Host>
 
      <Host name="www.c.com"  appBase="/data/web3"
            unpackWARs="true" autoDeploy="true">
            </Host>
#找到host主机项，注意根目录中一定要有ROOT这是默认的主目录
#注意默认的结束</HOST>这段要在默认结束的后面加上

systemctl restart tomcat
#重启tomcat服务


##验证（使用另一台设备）
[root@liuyanfen12 ~]#vim /etc/hosts
192.168.10.11 www.a.com www.b.com www.c.com
#另一台设备添加www.a.com，www.b.com，www.c.com

[root@liuyanfen12 ~]#curl www.b.com:8080
#访问验证

[root@liuyanfen12 ~]#curl www.b.com:8080
#访问验证

[root@liuyanfen12 ~]#curl www.c.com:8080
#访问验证

6.4 Context配置

Context作用

• 路径映射：将url映射至指定路径，而非使用appBase下的物理目录，实现虚拟目录功能
• 应用独立配置，例如单独配置应用日志、单独配置应用访问控制

#映射指定路径
<Context path="/test" docBase="/data/test" reloadable="true" />
#映射站点的根目录
<Context path="/" docBase="/data/website" reloadable="true" />
#还可以添加日志等独立的配置
<Context path="/test" docBase="/data/test" reloadable="true" >
  <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
               prefix="localhost_test_log" suffix=".txt"
               pattern="%h %l %u %t &quot;%r&quot; %s %b" />
</Context>

说明：

• path：指的是访问的URL路径，如果path与appBase下面的子目录同名，context的docBase路径优先更高
• docBase：可以是磁盘文件的绝对路径，也可以是相对路径（相对于Host的appBase）
• reloadable：true表示如果WEB-INF/classes或META-INF/lib目录下.class文件有改动，就会将WEB应用重新加载。生产环境中，建议使用false来禁用。

cd /data

mkdir test

echo test > test/index.html

#修改配置文件，添加下面第三行内容
vim /usr/local/tomcat/conf/server.xml
<Host name="www.a.com"  appBase="/data/web1"
            unpackWARs="true" autoDeploy="true">
        <Context path="/test" docBase="/data/test" reloadable="false" />
        #如果访问 www.a.com/test/ 那么就替换成"/data/test
      </Host>

systemctl restart tomcat
#重启服务

##验证
[root@liuyanfen12 ~]#curl www.a.com:8080/test/
test
#使用另一台设备访问www.a.com/test，替换成/data/test页面内容

四、Tomcat、Nginx 动静分离

1、单机反向代理

• 利用nginx反向代理实现全部转发到指定的同一个虚拟主机

配置环境

web服务器：192.168.10.11
代理服务器：192.168.10.12
客户端：192.168.10.13

1、web服务器（地址：192.168.10.11）
web服务器配置按照之前的修改，不用改变


2、代理服务器（地址：192.168.10.12）
yum install -y epel-release.noarch
#安装yum额外源包

yum install -y nginx
#yum安装nginx

systemctl start nginx
#开启nginx服务

#修改主机配置文件
vim /etc/hosts
192.168.10.11 www.a.com www.b.com www.c.com
#添加web服务器（192.168.10.11）ip地址

#修改配置文件
vim /etc/nginx/nginx.conf
location / {
        proxy_pass http://www.b.com:8080;
        #访问 / 时，跳转到www.b.com
        }
#在server模块下添加location模块反向代理

nginx -t
#检查语法

nginx -s reload
#重新加载配置文件


3、客户端（地址：192.168.10.13）
yum install -y epel-release.noarch
#安装yum额外源包

yum install -y nginx
#yum安装nginx

systemctl start nginx
#开启nginx服务

#修改主机配置文件
vim /etc/hosts
192.168.10.12 www.a.com www.b.com www.c.com
#添加代理服务器（192.168.10.12）ip地址


4、验证
curl www.a.com
curl www.b.com
curl www.c.com
#不论访问哪个，均跳转到指定页面

2、多机反向代理—实现负载均衡、动静分离

Nginx+Tomcat负载均衡、动静分离

配置环境：

Nginx 服务器：192.168.10.11（安装nginx服务）
Tomcat服务器1：192.168.10.12（安装tomcat服务）
Tomcat服务器2：192.168.10.13（安装tomcat服务）

1、部署Nginx 负载均衡器（192.168.10.11）
systemctl stop firewalld
setenforce 0
#关闭防火墙和防护中心

yum install -y epel-release.noarch
#安装额外源码包

yum install -y nginx
#安装nginx

systemctl start nginx.service
#开启服务

systemctl status nginx.service
#查看状态

#修改配置文件
vim /etc/nginx/nginx.conf
#在http模块下添加upstream模块（负载均衡）
upstream tomcat {
   server 192.168.10.12:8080;
   server 192.168.10.13:8080;
   }
#在server模块下添加location模块（反向代理，负载均衡）
 location ~* \.jsp$ {
    proxy_pass http://tomcat;
    }
    location ~* \.(jpg|png|html)$ {
    root /data/html;
    }

mkdir -p /data/html
#建立文件夹

nginx -t
#检查语法错误

nginx -s reload
#重新加载配置文件

cd /data/html
#切换目录

echo qqqqqq > q.html
#写入页面内容

cat q.html
#查看页面内容


2、部署2台 Tomcat 应用服务器
systemctl stop firewalld
setenforce 0
#关闭防火墙和防护中心

（1）先部署安装jdk
tar xf jdk-8u291-linux-x64.tar.gz -C /usr/local
#上传需要的jdk压缩包，解压到指定的目录

tar xf jdk-8u291-linux-x64.tar.gz -C /usr/local
#将二进制包解压到/usr/local目录

cd /usr/local/
#切换目录

ln -s jdk1.8.0_291/ jdk
#做软连接

#修改环境变量
vim /etc/profile.d/jdk.sh
export JAVA_HOME=/usr/local/jdk
export PATH=$JAVA_HOME/bin:$PATH
export JRE_HOME=$JAVA_HOME/jre   
export CLASSPATH=$JAVA_HOME/lib/:$JRE_HOME/lib/

. /etc/profile.d/jdk.sh
#运行

java -version
#查看版本

（2）安装tomcat
#将需要的tomcat二进制包上传

tar xf apache-tomcat-9.0.16.tar.gz 
#解压到指定目录

cp -r apache-tomcat-9.0.16 /usr/local/
#复制

cd /usr/local
#切换目录

ln -s apache-tomcat-9.0.16/ tomcat
#做软连接

/usr/local/tomcat/bin/startup.sh
#启动tomcat
Using CATALINA_BASE:   /usr/local/tomcat
Using CATALINA_HOME:   /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME:        /usr/local/jdk/jre
Using CLASSPATH:       /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
Tomcat started.

使用浏览器访问：192.168.10.12:8080（或者192.168.10.13:8080）

/usr/local/tomcat/bin/shutdown.sh
#关闭tomcat

useradd -M -s /sbin/nologin tomcat
#新建用户

chown tomcat:tomcat /usr/local/tomcat/ -R
#修改属主和属组

vim /usr/lib/systemd/system/tomcat.service
[Unit]
Description=Tomcat
After=syslog.target network.target

[Service]
Type=forking
ExecStart=/usr/local/tomcat/bin/startup.sh
ExecStop=/usr/local/tomcat/bin/shutdown.sh
RestartSec=3
PrivateTmp=true
User=tomcat
Group=tomcat

[Install]
WantedBy=multi-user.target
   
systemctl daemon-reload
#重新加载配置

systemctl start tomcat
#开启服务

ss -ntap |grep 8080
#查看开启的端口号


3、动静分离配置
（1）Tomcat1 server （192.168.10.12）配置
cd /usr/local/tomcat/webapps/ROOT
#切换目录

echo this is 192.168.10.12 > test.jsp
#建立tomcat页面显示内容


（2）Tomcat2 server （192.168.10.13）配置
cd /usr/local/tomcat/webapps/ROOT
#切换目录

echo this is 192.168.10.13 > test.jsp
#建立tomcat页面显示内容


4、验证
curl 192.168.10.11/q.html
#访问静态页面，nginx服务器自己响应，显示页面qqqqqq

curl 192.168.10.11/test.jsp
#访问动态页面，测试负载均衡效果，显示页面this is 192.168.10.12或this is 192.168.10.13

3、多机多级反向代理—实现负载均衡、动静分离

Nginx+Tomcat负载均衡、动静分离

配置环境：

Nginx 代理服务器：192.168.10.11（代理服务器，安装nginx服务）
nginx服务器：192.168.10.14 （安装nginx服务）
nginx服务器：192.168.10.15 （安装nginx服务）
Tomcat服务器1：192.168.10.12（后端服务器，安装tomcat服务）
Tomcat服务器2：192.168.10.13（后端服务器，安装tomcat服务）

1、代理服务器（地址：192.168.10.11）
#修改配置文件
vim /etc/nginx/nginx.conf
#在http模块下添加upstream模块（负载均衡）
upstream web {
   server 192.168.10.14;
   server 192.168.10.15;
   }
#在server模块下添加location模块（反向代理，负载均衡）
 location / {
    proxy_pass http://web;
    }
    location ~* \.(jpg|png|html)$ {
    root /data/html;
    }

nginx -t
#检查语法错误

nginx -s reload
#重新加载配置文件


2、部署两台nginx服务器（地址：192.168.10.14、192.168.10.15）
systemctl stop firewalld
setenforce 0
#关闭防火墙和防护中心

yum install -y epel-release.noarch
#安装额外源码包

yum install -y nginx
#安装nginx

systemctl start nginx.service
#开启服务

systemctl status nginx.service
#查看状态

(1)配置第一台nginx服务器（地址：192.168.10.14）
cd /usr/share/nginx/html
#切换目录

#修改页面显示内容
vim index.html
this is 192.168.10.14

#修改配置文件
vim /etc/nginx/nginx.conf
#在http模块下添加upstream模块（负载均衡）
upstream tomcat {
   server 192.168.10.12:8080;
   server 192.168.10.13:8080;
   }
#在server模块下添加location模块（反向代理，负载均衡）
 location ~* \.jsp$ {
    proxy_pass http://tomcat;
    }
    location ~* \.(jpg|png|html)$ {
    root /usr/share/nginx/html;
    }

nginx -t
#检查语法错误

nginx -s reload
#重新加载配置文件

scp /etc/nginx/nginx.conf 192.168.10.15:/opt
#将192.168.10.14的nginx配置文件复制到192.168.10.15的/opt目录下

(2)配置第二台nginx服务器（地址：192.168.10.15）
cd /usr/share/nginx/html
#切换目录

#修改页面显示内容（192.168.10.15）
vim index.html
this is 192.168.10.15

cp /opt/nginx.conf /etc/nginx/nginx.conf
#复制配置文件

nginx -s reload
#重新加载配置文件


3、验证
curl 192.168.10.11/q.html
#访问静态页面，nginx服务器自己响应，显示页面qqqqqq

curl 192.168.10.11/test.jsp
#访问动态页面，测试负载均衡效果，显示页面this is 192.168.10.12或this is 192.168.10.13

• 一层代理配置（地址：192.168.10.11）

• 验证（访问nginx服务器）

• 二层代理配置（地址：192.168.10.14、192.168.10.15）

• 验证（访问tomcat后端服务器）

五、Tomcat优化

在目前流行的互联网架构中，Tomcat在目前的网络编程中是举足轻重的，由于Tomcat的运行依赖于JVM，从虚拟机的角度把Tomcat的调整分为外部环境调优 JVM 和 Tomcat 自身调优两部分

1、JVM组成

1.1 JVM组成部分

• 类加载子系统: 使用Java语言编写.java Source Code文件，通过javac编译成.class Byte Code文件。class loader类加载器将所需所有类加载到内存，必要时将类实例化成实例
• 运行时数据区: 最消耗内存的空间,需要优化
• 执行引擎: 包括JIT (JustInTimeCompiler)即时编译器, GC垃圾回收器
• 本地方法接口: 将本地方法栈通过JNI(Java Native Interface)调用Native Method Libraries, 比如:C,C++库等,扩展Java功能,融合不同的编程语言为Java所用

JVM运行时数据区域由下面部分构成：

• **Method Area (线程共享)：**方法区是所有线程共享的内存空间，存放已加载的类信息(构造方法,接口定义),常量(final),静态变量(static), 运行时常量池等。但实例变量存放在堆内存中. 从JDK8开始此空间由永久代改名为元空间
• heap (线程共享)：堆在虚拟机启动时创建,存放创建的所有对象信息。如果对象无法申请到可用内存将抛出OOM异常.堆是靠GC垃圾回收器管理的,通过-Xmx -Xms 指定最大堆和最小堆空间大小
• **Java stack (线程私有)：**Java栈是每个线程会分配一个栈，存放java中8大基本数据类型,对象引用,实例的本地变量,方法参数和返回值等,基于FILO()（First In Last Out）,每个方法为一个栈帧 1 50 %
• **Program Counter Register (线程私有)：**PC寄存器就是一个指针,指向方法区中的方法字节码,每一个线程用于记录当前线程正在执行的字节码指令地址。由执行引擎读取下一条指令.因为线程需要切换，当一个线程被切换回来需要执行的时候，知道执行到哪里了
• **Native Method stack (线程私有)：**本地方法栈为本地方法执行构建的内存空间，存放本地方法执行时的局部变量、操作数等。

1.2 虚拟机

目前Oracle官方使用的是HotSpot， 它最早由一家名为"Longview Technologies"公司设计，使用了很多优秀的设计理念和出色的性能，1997年该公司被SUN公司收购。后来随着JDK一起发布了HotSpot VM。目前HotSpot是最主要的 JVM。

安卓程序需要运行在JVM上，而安卓平台使用了Google自研的Java虚拟机——Dalvid，适合于内存、处理器能力有限系统。

在堆内存中如果创建的对象不再使用,仍占用着内存,此时即为垃圾.需要即使进行垃圾回收,从而释放内存空间给其它对象使用

其实不同的开发语言都有垃圾回收问题,C,C++需要程序员人为回收,造成开发难度大,容易出错等问题,但执行效率高,而JAVA和Python中不需要程序员进行人为的回收垃圾,而由JVM或相关程序自动回收垃圾,减轻程序员的开发难度,但可能会造成执行效率低下

堆内存里面经常创建、销毁对象，内存也是经常被使用、被释放。如果不妥善处理，一个使用频繁的进程，可能会出现虽然有足够的内存容量，但是无法分配出可用内存空间，因为没有连续成片的内存了，内存全是碎片化的空间。

所以需要有合适的垃圾回收机制,确保正常释放不再使用的内存空间,还需要保证内存空间尽可能的保持一定的连续

1.3 Garbage 垃圾确定方法

• 引用计数: 每一个堆内对象上都与一个私有引用计数器，记录着被引用的次数，引用计数清零，该对象所占用堆内存就可以被回收。循环引用的对象都无法将引用计数归零，就无法清除。Python中即使用此种方式。 简单来说就是有个笔记本，记录有没有人在用，缺陷，AB 资源互相调用
• 根搜索(可达)算法 Root Searching

2、垃圾回收基本算法

2.1 标记-清除 Mark-Sweep

分垃圾标记阶段和内存释放阶段。标记阶段，找到所有可访问对象打个标记。清理阶段，遍历整个堆，对未标记对象(即不再使用的对象)逐一进行清理。

标记-清除最大的问题会造成内存碎片,但是不浪费空间,效率较高(如果对象较多,逐一删除效率也会影响)

2.2 标记压缩 (压实)Mark-Compact

分垃圾标记阶段和内存整理阶段。标记阶段，找到所有可访问对象打个标记。内存清理阶段时，整理时将对象向内存一端移动，整理后存活对象连续的集中在内存一端。

标记-压缩算法好处是整理后内存空间连续分配，有大段的连续内存可分配，没有内存碎片。缺点是内存整理过程有消耗,效率相对低下

2.3 复制 （Copying）

先将可用内存分为大小相同两块区域A和B，每次只用其中一块，比如A。当A用完后，则将A中存活的对象复制到B。复制到B的时候连续的使用内存，最后将A一次性清除干净。缺点是比较浪费内存，只能使用原来一半内存，因为内存对半划分了，复制过程毕竟也是有代价。好处是没有碎片，复制过程中保证对象使用连续空间,且一次性清除所有垃圾,所以效率很高。

2.4 多种算法总结

没有最好的算法,在不同场景选择最合适的算法

• 效率: 复制算法>标记清除算法> 标记压缩算法
• 内存整齐度: 复制算法=标记压缩算法> 标记清除算法
• 内存利用率: 标记压缩算法=标记清除算法>复制算法

2.5 STW

对于大多数垃圾回收算法而言，GC线程工作时，停止所有工作的线程，称为Stop The World。GC 完成时，恢复其他工作线程运行。这也是JVM运行中最头疼的问题。

3、分代堆内存GC策略

3.1 堆内存分代

上述垃圾回收算法都有优缺点，能不能对不同数据进行区分管理，不同分区对数据实施不同回收策略，分而治之

将heap内存空间分为三个不同类别: 年轻代、老年代、持久代

Heap堆内存分为

• 年轻代Young：Young Generation

伊甸园区eden: 只有一个,刚刚创建的对象幸存(存活)区Servivor Space：有2个幸存区，一个是from区，一个是to区。大小相等、地位相同、可互换。

from 指的是本次复制数据的源区
to 指的是本次复制数据的目标区

• 老年代Tenured：Old Generation, 长时间存活的对象

默认空间大小比例:

3.2 年轻代回收 Minor GC

• 起始时，所有新建对象(特大对象直接进入老年代)都出生在eden，当eden满了，启动GC。这个称为Young GC 或者 Minor GC。
• 先标记eden存活对象，然后将存活对象复制到s0（假设本次是s0，也可以是s1，它们可以调换），eden剩余所有空间都清空。GC完成。
• 继续新建对象，当eden再次满了，启动GC。
• 先同时标记eden和s0中存活对象，然后将存活对象复制到s1。将eden和s0清空,此次GC完成
• 继续新建对象，当eden满了，启动GC。
• 先标记eden和s1中存活对象，然后将存活对象复制到s0。将eden和s1清空,此次GC完成以后就重复上面的步骤。

通常场景下,大多数对象都不会存活很久，而且创建活动非常多，新生代就需要频繁垃圾回收。但是，如果一个对象一直存活，它最后就在from、to来回复制，如果from区中对象复制次数达到阈值(默认15次,CMS为6次,可通过java的选项 -XX:MaxTenuringThreshold=N 指定)，就直接复制到老年代。

3.3 老年代回收 Major GC

• 进入老年代的数据较少，所以老年代区被占满的速度较慢，所以垃圾回收也不频繁。如果老年代也满了,会触发老年代GC,称为Old GC或者 Major GC。

• 由于老年代对象一般来说存活次数较长，所以较常采用标记-压缩算法。

• 当老年代满时,会触发 Full GC,即对所有"代"的内存进行垃圾回收

• Minor GC比较频繁，Major GC较少。但一般Major GC时，由于老年代对象也可以引用新生代对象，所以先进行一次Minor GC，然后在Major GC会提高效率。可以认为回收老年代的时候完成了一次Full GC。所以可以认为 MajorGC = FullGC

4、java 内存调整相关参数

4.1 JVM 内存常用相关参数

Java 命令行参考文档

https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html

帮助：man java

选项分类

• -选项名称：此为标准选项,所有HotSpot都支持
• -X选项名称：为稳定的非标准选项
• -XX:选项名称：非标准的不稳定选项，下一个版本可能会取消

参数	说明	举例
-Xms	设置应用程序初始使用的堆内存大小（年轻代+老年代）	-Xms2g
-Xmx	设置应用程序能获得的最大堆内存早期JVM不建议超过32G，内存管理效率下降	-Xms4g
-XX:NewSize	设置初始新生代大小	-XX:NewSize=128m
-XX:MaxNewSize	设置最大新生代内存空间	-XX:MaxNewSize=256m
-Xmnsize	同时设置-XX:NewSize 和 -XX:MaxNewSize，代	-Xmn1g
-XX:NewRatio	以比例方式设置新生代和老年代	-XX:NewRatio=2new/old=1/2
-XX:SurvivorRatio	以比例方式设置eden和survivor(S0或S1）	-XX:SurvivorRatio=6eden/survivor=6/1new/survivor=8/1
-Xss	设置每个线程私有的栈空间大小,依据具体线程	-Xss256k

标准选项

[root@localhost ~]#java
用法: java [-options] class [args...]
           (执行类)
   或  java [-options] -jar jarfile [args...]
           (执行 jar 文件)
其中选项包括:
    -d32	  使用 32 位数据模型 (如果可用)
    -d64	  使用 64 位数据模型 (如果可用)
    -server	  选择 "server" VM
                  默认 VM 是 server,
                  因为您是在服务器类计算机上运行。


    -cp <目录和 zip/jar 文件的类搜索路径>
    -classpath <目录和 zip/jar 文件的类搜索路径>
                  用 : 分隔的目录, JAR 档案
                  和 ZIP 档案列表, 用于搜索类文件。
    -D<名称>=<值>
                  设置系统属性
    -verbose:[class|gc|jni]
                  启用详细输出
    -version      输出产品版本并退出
    -version:<值>
                  警告: 此功能已过时, 将在
                  未来发行版中删除。
                  需要指定的版本才能运行
    -showversion  输出产品版本并继续
    -jre-restrict-search | -no-jre-restrict-search
                  警告: 此功能已过时, 将在
                  未来发行版中删除。
                  在版本搜索中包括/排除用户专用 JRE
    -? -help      输出此帮助消息
    -X            输出非标准选项的帮助
    -ea[:<packagename>...|:<classname>]
    -enableassertions[:<packagename>...|:<classname>]
                  按指定的粒度启用断言
    -da[:<packagename>...|:<classname>]
    -disableassertions[:<packagename>...|:<classname>]
                  禁用具有指定粒度的断言
    -esa | -enablesystemassertions
                  启用系统断言
    -dsa | -disablesystemassertions
                  禁用系统断言
    -agentlib:<libname>[=<选项>]
                  加载本机代理库 <libname>, 例如 -agentlib:hprof
                  另请参阅 -agentlib:jdwp=help 和 -agentlib:hprof=help
    -agentpath:<pathname>[=<选项>]
                  按完整路径名加载本机代理库
    -javaagent:<jarpath>[=<选项>]
                  加载 Java 编程语言代理, 请参阅 java.lang.instrument
    -splash:<imagepath>
                  使用指定的图像显示启动屏幕
有关详细信息, 请参阅 http://www.oracle.com/technetwork/java/javase/documentation/index.html。

非标准的稳定选项

[root@localhost ~]#java -X
    -Xmixed           混合模式执行 (默认)
    -Xint             仅解释模式执行
    -Xbootclasspath:<用 : 分隔的目录和 zip/jar 文件>
                      设置搜索路径以引导类和资源
    -Xbootclasspath/a:<用 : 分隔的目录和 zip/jar 文件>
                      附加在引导类路径末尾
    -Xbootclasspath/p:<用 : 分隔的目录和 zip/jar 文件>
                      置于引导类路径之前
    -Xdiag            显示附加诊断消息
    -Xnoclassgc       禁用类垃圾收集
    -Xincgc           启用增量垃圾收集
    -Xloggc:<file>    将 GC 状态记录在文件中 (带时间戳)
    -Xbatch           禁用后台编译
    -Xms<size>        设置初始 Java 堆大小
    -Xmx<size>        设置最大 Java 堆大小
    -Xss<size>        设置 Java 线程堆栈大小
    -Xprof            输出 cpu 配置文件数据
    -Xfuture          启用最严格的检查, 预期将来的默认值
    -Xrs              减少 Java/VM 对操作系统信号的使用 (请参阅文档)
    -Xcheck:jni       对 JNI 函数执行其他检查
    -Xshare:off       不尝试使用共享类数据
    -Xshare:auto      在可能的情况下使用共享类数据 (默认)
    -Xshare:on        要求使用共享类数据, 否则将失败。
    -XshowSettings    显示所有设置并继续
    -XshowSettings:all
                      显示所有设置并继续
    -XshowSettings:vm 显示所有与 vm 相关的设置并继续
    -XshowSettings:properties
                      显示所有属性设置并继续
    -XshowSettings:locale
                      显示所有与区域设置相关的设置并继续

-X 选项是非标准选项, 如有更改, 恕不另行通知。

有不稳定选项的当前生效值

[root@localhost ~]#java -XX:+PrintFlagsFinal

查看所有不稳定选项的默认值

[root@localhost ~]#java -XX:+PrintFlagsInitial

4.2 JDK工具监控使用情况

4.3 Tomcat的JVM参数设置

• 默认不指定，-Xmx大约使用了1/4的内存，当前本机内存指定约为1G。

在/usr/local/tomcat/conf/bin/catalina.sh中增加一行

......
118行
# OS specific support. $var _must_ be set to either true or false.  
#添加下面一行    
JAVA_OPTS="-server -Xms128m -Xmx512m -XX:NewSize=100m -XX:MaxNewSize=200m"
                                                            
cygwin=false
darwin=false


JAVA_OPTS="-server -Xms4g -Xmx4g -XX:NewSize= -XX:MaxNewSize= "
-server：服务器模式
-Xms：堆内存初始化大小
-Xmx：堆内存空间上限
-XX:NewSize=：新生代空间初始化大小 
-XX:MaxNewSize=：新生代空间最大值

5、Tomcat 配置文件参数优化

Tomcat默认安装下的缺省配置并不适合生产环境，它可能会频繁出现假死现象需要重启，只有通过不断压测优化才能让它最高效率稳定的运行。优化主要包括三方面，分别为操作系统优化（内核参数优化），Tomcat配置文件参数优化，Java虚拟机（JVM）调优。

#Tomcat 配置文件参数优化##
常用的优化相关参数如下：
【redirectPort】如果某连接器支持的协议是HTTP，当接收客户端发来的HTTPS   443 请求时，则转发至此属性定义的 8443 端口。

【maxThreads】Tomcat使用线程来处理接收的每个请求，这个值表示Tomcat可创建的最大的线程数，即支持的最大并发连接数，默认值是 200。

【minSpareThreads】最小空闲线程数，Tomcat 启动时的初始化的线程数，表示即使没有人使用也开这么多空线程等待，默认值是 10。

【maxSpareThreads】最大备用线程数，一旦创建的线程超过这个值，Tomcat就会关闭不再需要的socket线程。默认值是-1（无限制）。一般不需要指定。

【processorCache】进程缓冲器，可以提升并发请求。默认值是200，如果不做限制的话可以设置为-1，一般采用maxThreads的值或者-1。

【URIEncoding】指定 Tomcat 容器的 URL 编码格式，网站一般采用UTF-8作为默认编码。

【connnectionTimeout】网络连接超时，单位：毫秒，设置为 0 表示永不超时，这样设置有隐患的。通常默认 20000 毫秒就可以。

【enableLookups】是否反查域名，以返回远程主机的主机名，取值为：true 或 false，如果设置为 false，则直接返回 IP 地址，为了提高处理能力，应设置为 false。

【disableUploadTimeout】上传时是否使用超时机制。应设置为 true。

【connectionUploadTimeout】上传超时时间，毕竟文件上传可能需要消耗更多的时间，这个根据你自己的业务需要自己调，以使Servlet有较长的时间来完成它的执行，需要与上一个参数一起配合使用才会生效。

【acceptCount】指定当所有可以使用的处理请求的线程数都被使用时，可传入连接请求的最大队列长度，超过这个数的请求将不予处理，默认为 100 个。

【maxKeepAliveRequests】指定一个长连接的最大请求数。默认长连接是打开的，设置为1时，代表关闭长连接；为-1时，代表请求数无限制

【compression】是否对响应的数据进行GZIP压缩，off：表示禁止压缩；on：表示允许压缩（文本将被压缩）、force：表示所有情况下都进行压缩，默认值为 off，压缩数据后可以有效的减少页面的大小，一般可以减小 1/3 左右，节省带宽。

【compressionMinSize】表示压缩响应的最小值，只有当响应报文大小大于这个值的时候才会对报文进行压缩，如果开启了压缩功能，默认值就是 2048。

【compressableMimeType】压缩类型，指定对哪些类型的文件进行数据压缩。

【noCompressionUserAgents="gozilla, traviata"】对于以下的浏览器，不启用压缩
#如果已经进行了动静分离处理，静态页面和图片等数据就不需做 Tomcat 处理，也就不要在 Tomcat 中配置压缩了。

以上是一些常用的配置参数，还有好多其它的参数设置，还可以继续深入的优化，HTTP Connector 与 AJP Connector 的参数属性值，可以参考官方文档的详细说明进行学习。


vim /usr/local/tomcat/conf/server.xml
......
<Connector port="8080" protocol="HTTP/11.1" 
connectionTimeout="20000" 
redirectPort="8443" 
--71行--插入
minSpareThreads="50" 
enableLookups="false" 
disableUploadTimeout="true" 
acceptCount="300" 
maxThreads="500" 
processorCache="500"
URIEncoding="UTF-8" 
maxKeepAliveRequests="100"
compression="on" 
compressionMinSize="2048" 
compressableMimeType="text/html,text/xml,text/javascript,text/css,text/plain,image/gif,image /jpg,image/png"/>

六、Nginx 负载均衡模式

1、rr 负载均衡模式

每个请求按时间顺序逐一分配到不同的后端服务器，如果超过了最大失败次数后（max_fails，默认1），在失效时间内(fail_timeout，默认10秒)，该节点失效权重变为0，超过失效时间后，则恢复正常，或者全部节点都为down后，那么将所有节点都恢复为有效继续探测，一般来说rr可以根据权重来进行均匀分配。

2、least_conn 最少连接

优先将客户端请求调度到当前连接最少的服务器。

3、ip_hash 负载均衡模式

每个请求按访问ip的hash结果分配，这样每个访客固定访问一个后端服务器，可以解决session的问题，但是ip_hash会造成负载不均，有的服务请求接受多，有的服务请求接受少，所以不建议采用ip_hash模式，session 共享问题可用后端服务的 session 共享代替 nginx 的 ip_hash（使用后端服务器自身通过相关机制保持session同步）。

4、fair（第三方）负载均衡模式

按后端服务器的响应时间来分配请求，响应时间短的优先分配。

5、url_hash（第三方）负载均衡模式

基于用户请求的uri做hash。和ip_hash算法类似，是对每个请求按url的hash结果分配，使每个URL定向到同一个后端服务器，但是也会造成分配不均的问题，这种模式后端服务器为缓存时比较好。

拓展：Tomcat 主配置文件常用的优化相关参数如下

关于 Tomcat 主配置文件 server.xml 里面很多默认的配置项，但并不能满足业务需求，常用的优化相关参数如下：

• 【maxThreads】Tomcat 使用线程来处理接收的每个请求，这个值表示 Tomcat 可创建的最大的线程数，默认值是 200。

• 【minSpareThreads】最小空闲线程数，Tomcat 启动时的初始化的线程数，表示即使没有人使用也开这么多空线程等待，默认值是 10

• 【maxSpareThreads】最大备用线程数，一旦创建的线程超过这个值，Tomcat 就会关闭不再需要的 socket 线程。默认值是-1（无限制）。一般不需要指定

• 【URIEncoding】指定 Tomcat 容器的 URL 编码格式，语言编码格式这块倒不如其它 Web服务器软件配置方便，需要分别指定utf-8

• 【connnectionTimeout】网络连接超时，单位：毫秒，设置为 0 表示永不超时，这样设置有隐患的。通常默认 20000 毫秒（20秒）就可以

• 【enableLookups】是否反查域名，以返回远程主机的主机名，取值为：true 或 false，如果设置为 false，则直接返回 IP 地址，为了提高处理能力，应设置为 false。

• 【disableUploadTimeout】上传时是否使用超时机制。应设置为 true。

• 【connectionUploadTimeout】上传超时时间，毕竟文件上传可能需要消耗更多的时间，这个根据你自己的业务需要自己调，以使 Servlet 有较长的时间来完成它的执行，需要与上一个参数一起配合使用才会生效

• 【acceptCount】指定当所有可以使用的处理请求的线程数都被使用时，可传入连接请求的最大队列长度，超过这个数的请求将不予处理，默认为 100 个。

• 【compression】是否对响应的数据进行 GZIP 压缩，off：表示禁止压缩；on：表示允许压缩（文本将被压缩）、force：表示所有情况下都进行压缩，默认值为 off，压缩数据后可以有效的减少页面的大小，一般可以减小 1/3 左右，节省带宽。

• 【compressionMinSize】表示压缩响应的最小值，只有当响应报文大小大于这个值的时候才会对报文进行压缩，如果开启了压缩功能，默认值就是 2048

• 【compressableMimeType】压缩类型，指定对哪些类型的文件进行数据压缩。

• 【noCompressionUserAgents=“gozilla, traviata”】对于以下的浏览器，不启用压缩，如果已经对代码进行了动静分离，静态页面和图片等数据就不需要 Tomcat 处理了，那么也就不需要在 Tomcat 中配置压缩了。因为这里只有一台 Tomcat 服务器，而且压测的是Tomcat 首页，会有图片和静态资源文件，所以这里启用压缩。