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/ 官网
Tomcat顶层架构
Tomcat中最顶层的容器是Server，代表着整个服务器，一个Server可以包含至少一个Service，用于具体提供服务。
Service主要包含两个部分:Connector和Container。Tomcat的心脏就是这两个组件，这两个组件的作用:Connector用于处理连接相关的事情，并提供Socket与Request和Response相关的转化; Container用于封装和管理Servlet，以及具体处理Request请求。
一个Tomcat中只有一个Server，一个Server可以包含多个Service，一个Service只有一个Container,但是可以有多个Connectors，因为一个服务可以有多个连接，如同时提供Http和Https链接，也可以提供向相同协议不同端口的连接。
多个Connector和一个Container就形成了一个Service，有了Service就可以对外提供服务了，但是Service还要一个生存的环境，必须要有人能够给它生命、掌握其生死大权，那就非Server莫属了!所以整个Tomcat的生命周期由Server控制。另外，上述的包含关系或者说是父子关系，都可以在tomcat的conf目录下的server .xml配置文件中看出。
server.xm1中定义这会让Tomcat6启动一个server实例(即一个JVM)，它监听在8005端口以接收“SHUTDOWN”命令，如果接收到了就会关闭Tomcat。各Server的定义不能使用同一个端口，这意味着如果在同一个物理机上启动了多个Server实例，必须配置它们使用不同的端口。
四个子容器的作用分别是:
(1) Engine: 引擎，用来管理多个站点，一个Service最多只能有一个Engine;
(2) Host:代表一个站点，也可以叫虚拟主机，通过配置Host就可以添加站点;
(3) Context:代表一个应用程序，对应着平时开发的一套程序，或者一个WEB-INF目录以及下面的web.xml文件;
(4) Wrapper: 每一Wrapper封装着 一个Servlet;
Tomcat请求过程
（1）用户在浏览器中输入该网址，请求被发送到本机端口8080，被在那里监听的Coyote HTTP/1.1 Connector获得;
（2）Connector把该请求交给它所在的Service的Engine (Container) 来处理，并等待Engine的回应;
（3）Engine获得请求localhost/test/index.jsp，匹配所有的虚拟主机Host;
（4）Engine匹配到名为localhost的Host(即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机)，名为localhostHost获得请求/test/index.jsp，匹配它所拥有的所有Context。Host匹配到路径为/test的Context(如果匹配不到就把该请求交给路径名为“”的Context去处理);
（5）path="/test"的Context获得请求/ index. jsp，在它的mapping table中寻找出对应的Servlet。Context 匹配到URLPattern为* .jsp的Servlet，对应于JspServlet类;
（6）构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet()或doPost(),执行业务逻辑、数据存储等
（7）Context把执行完之后的HttpServletResponse对象返回给Host; .
（8）Host把HttpServletResponse对象返回给Engine;
（9）Engine把HttpServletResponse对象返回Connector;
（10）Connector把HttpServletResponse对象返回给客户Browser
Web 技术
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编程。
前端三大核心技术
Html Css Javascript
Javascript简称S，是一种动态的弱类型脚本解释性语言，和HTML、CSS并称三大WEB核心技术，得到了几乎主流浏览器支持。
1994年，网景Netscape公司成立并发布了Netscape Navigator刘览器，占据了很大的市场份额，网景意识到WEB需要动态，需要一种技术来实现。
1995年9月网景浏览器2发布测试版本发布了LiveScript，随即在12月的测试版就更名为JavaScript。同时期，微软推出IE并支持Sscript、VBScript，与之抗衡。
1997年，网景、微软、SUN、Borland公司和其他组织在ECMA(European Ccomputer Manufacturers Association欧洲计算机制造商协会)确定了EGMAScript的本程序设计语言的标准。JavaScript和JScript都成为ECMAScript标准的实现。
2008年后随着chrome浏览器的V8引|擎发布。
V8JS引|擎不是解释执行，而是本地编译，在V8B引擎做了很多优化，JS程序在其上运行堪比本地二进制程序。V8引擎使用C++开发，可以嵌入到任何C++程序中。基于V8引擎，2009年基于服务器javascript的运行环境Node.js诞生，创建了第一版npm (Node js包管理嚣和开源库生态系统)提供了大显的库供程序员使用。从此，便可以在服务器端真正大规模使用jJvaScript编程了。也就是说JavaScript 也可以真正称为服务器端编程语言了，成为目前唯一的前，后端通用的语言。
同步：
交互式网页，用户提交了请求，就是想看到查询的结果。服务器响应到来后是一个全新的页面内容，哪怕URL不变，整个网页都需要重新渲染。例如，用户填写注册信息，只是2次密码不一致，提交后，整个注册页面重新刷新，所有填写项目重新填写(当然有办法让用户减少重填)。这种交互非常不友好。从代价的角度看，就是为了注册的一点点信息，结果返回了整个网页内容，不但浪费了网络带宽，还需要浏览器重新渲染网页，太浪费资源了，影响了用户体验和感受。上面这些请求的过程，就是同步过程，用户发起请求，页面整个刷新，直到服务器端响应的数据到来并重新渲染。
异步：
1996年微软实现了iframe标签，可以在一个网页使用iframe标签局部异步加载内容。
1999年微软推出异步数据传输的ActiveX插件技术，太笨重了，但是也火了很多年。有一个组件XMLHttpRequest被大多数浏览器支持。
传统的网页如果需要更新内容，必需重数整个网页面。Ajax的出现，改变这一切，同时极大的促进了Javascript的发展。Ajax即"Asynchronous Javascript AndXML”(异步JavaScript和XML)，是指一种创建交互式、快速动态网页应用的网页开发技术，最早起源于1998年微软的Outook Web Access开发团队。Ajax通过在后台与服务器进行少量数据交换，可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。Javascript通过调用浏览器内置的WEB API中的XMLHttpRequest对象实现Ajax技术。早期Aijax结合数据格式XML，目前更多的使用)SON。利用AAX可实现前后端开发的彻底分离，改变了传统的开发模式。
Java基础
Web架构
Web资源和访问
PC端或移动端浏览器访问
从静态服务器请求HTML、CSS、JS等文件发送到浏览器端，浏览器端接收后渲染在浏览器上从图片服务器请求图片资源显示
从业务服务器访问动态内容，动态内容是请求后有后台服务访问数据库后得到的，最终返回到浏览器端
手机 App访问
内置了HTML和]S文件，不需要从静态WEB服务器下载JS或HTML。为的就是减少文件的发送，现代前端开发使用的S文件太多或太大了有必要就从图片服务器请求图片，从业务服务器请求动态数据
客户需求多样，更多的内容还是需要由业务服务器提供，业务服务器往往都是由一组服务器组成。
后台应用架构
单体应用架构
- 传统架构(单机系统)。-个项目一个工程:比如商品、订单、支付、库存、登录、注册等等，统-部署，一个进程
- all in one的架构方式，把所有的功能单元放在一 个应用里。然后把整个应用部署到一台服务器上。如果负载能力不行，将整个应用进行水平复制，进行扩展，然后通过负载均衡实现访问。
- Java实现: JSP、 Servlet, 打包成-个jar. war部署
- 易于开发和测试:也十分方便部署:当需要扩展时，只需要将war复制多份，然后放到多个服务器上，再做个负载均衡就可以了。
- 如果某个功能模块出问题，有可能全站不可访问，修改Bug后、某模块功能修改或升级后，需要停掉整个服务，重新整体重新打包、部署这个应用war包,功
能模块相互之间耦合度高，相互影响,不适合当今互联网业务功能的快速迭代。 - 特别是对于-一个大型应用，我们不可能吧所有内容都放在一 个应用里面，我们如何维护、如何分工合作都是问题。如果项目庞大，管理难度大
- web应用服务器:开源的tomcat. jetty. glassfish。 商用的有weblogic、websphere. Jboss
属于SOA (Service Oriented Architecture)的子集。
微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底去掉耦合，每一个微服务提供单个业务功能，一个服务只做一件事。每个服务都围绕着具体业务进行构建，并且能够被独立地部署到生产环境、类生产环境等
- 从技术角度讲就是一种小而独立的处理过程，类似与进程的概念，能够自行单独启动或销毁。
微服务架构（分布式系统)，各个模块/服务，各自独立出来，"让专业的人干专业的事”，独立部署。分布式系统中，不同的服务可以使用各自独立的数据库。·服务之间采用轻量级的通信机制(通常是基于HTTP的RESTful API)。
-
微服务设计的思想改变了原有的企业研发团队组织架构。传统的研发组织架构是水平架构，前端、后端、DBA、测试分别有自己对应的团队，属于水平团队组
织架构。而微服务的设计思想对团队的划分有着一定的影响，使得团队组织架构的划分更倾向于垂直架构，比如用户业务是一个团队来负责，支付业务是一个团队来负责。但实际上在企业中并不会把团队组织架构拆分得这么绝对，垂直架构只是一种理想的架构。 -
微服务的实现框架有多种，不同的应用架构，部署方式也有不同。
微服务的优缺点微服务优点
- 每个服务足够内聚，足够小，代码容易理解。这样能聚焦一个只当的业务功能或业务需求。
开发简单、开发效率提高，一个服务可能就是专业的只干一件事，微服务能够被小团队单独开发，这个小团队可以是2到5人的开发人员组成·微服务是松耦合的，是有功能意义的服务，无论是在开发阶段或部署阶段都是独立的。 - 微服务能使用不同的语言开发I
- 易于和第三方集成，微服务运行容易且灵活的方式集成自动部署，通过持续集成工具，如: Jenkins、Hudson、Bamboo·微服务易于被一个开发人员理解、修改和维护，这样小团队能够更关注自己的工作成果，无需通过合作才能体现价值。微服务允许你利用融合最新技术。微服务只是业务逻辑的代码，不会和HTML/CSS或其他界面组件混合，即前后端分离·每个微服务都有自己的存储能力，可以有自己的数据库，也可以有统一数据库
微服务缺点
- 微服务把原有的一个项目拆分成多个独立工程，增加了开发、测试、运维、监控等的复杂度
- 微服务架构需要保证不同服务之间的数据一致性，引入了分布式事务和异步补偿机制，为设计和开发带来一定挑战·开发人员和运维需要处理分布式系统的复杂性，需要更强的技术能力
- 微服务适用于复杂的大系统，对于小型应用使用微服务，进行盲目的拆分只会增加其维护和开发成本
Java
Java包含下面部分:
-
语言、语法规范。关键字,如: if、for、class等
-
源代码source code
-
依赖库，标准库(基础).I第三方库(针对某些应用)。底层代码太难使用且开发效率低，封装成现成的库
-
JVM虚拟机。将源代码编译为中间码即字节码后,再运行在JVM之上
由于各种操作系统ABl不一样，采用编译方式，需要为不同操作系统编译成相应格式的二进制程序才能运行。
1995年，Java发布Applet技术，Java程序在后台编译成字节码，发送到浏览器端，在浏览器中运行一个Applet程序，这段程序是运行在另外一个VM进程中的但是这种在客户端运行ava代码的技术，会有很大的安全问题。1997年CGl技术发展起来，动态网页技术开始向后端开发转移，在后端将动态内容组织好，拼成HTML发回到浏览器端。
实现动态网页功能
Servelt
本质是一段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 wor 1d";
}
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{
{
}
}
在Servlet中最大的问题是，HTML输出和lava代码混在一起，如果网页布局要调整，Java源代码就需要随之进行调整,对于开发人员来说就是噩梦。
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是基于Servlet实现，JSP将表现和逻辑分离，这样页面开发人员更好的注重页面表现力更好服务客户。
不过最终JSP还需要先转换为Servlet的源代码,java文件（Tomcat中使用asper转换)，只不过这个转换过程无需人工完成是通过工具自动实现的然后再编译成.class文件，最后才可以在JVM中运行。
比如:浏览器第一次请求testjspi时, Tomcat服务器会自动将testisp转化sltest.spjava这么一个类并将该文件编译成cass文件。编译完毕后再运行class文件来应浏览器的请求。如果以后访问testjsp就不再重新编译jsp文件了，直接调用class文件来响应浏览器。后续如果Tomcat检测到SP页面改动了的话，会重新编译
JSP类似于PHP和ASP,前端代码和后端JAVA代码混写在一起需要前端和后端工程师在一起协作才能完成,无法做到真正的前后端分离开发
在web早期的开发中，通常采用的分为两层，视图层和模型层。
Jdk
- Java SE APl: Java 基础类库开发接口
- JRE: Java Runtime Environment缩写，指Java运行时环境，包含JVM +Java核心类库
- JDK: Java Development Kit，即Java语言的软件开发工具包JDK协议基于JRL(JavaResearch License)协议
Tomcat介绍
Tomcat服务器是一个免费的开放源代码的Web应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，Tomcat具有处理HTML页面的功能，它还是一个Servlet和JSP容器。
起始于SUN公司的一个Servlet的参考实现项目Java Web Senver，开发者是James Duncan Davidson，在19年，将项目贡献给了apache软件基金会(ASF)，和ASF现有的项目JServ合并，并开源成为顶级项目。
Tomcat仅仅实现了Java EE规范中与Servlet、JSP相关的类库，是JavaEE不完整实现。
著名图书出版商O’Relly约稿该项目成员Davidson希望使用一个公猫作为封面，但是公猫已经被使用，书出版后封面是一只雪豹。
官网：http://tomcat.apache.org
基于java程序实现
实际操作安装tomcat
[root@localhost ~]#rpm -ivh jdk-8u201-linux-x64.rpm
#安装JDK包
警告：jdk-8u201-linux-x64.rpm: 头V3 RSA/SHA256 Signature, 密钥 ID ec551f03: NOKEY
准备中... ################################# [100%]
正在升级/安装...
1:jdk1.8-2000:1.8.0_201-fcs ################################# [100%]
[root@localhost ~]#cd /usr/java/jdk1.8.0_201-amd64/
[root@localhost jdk1.8.0_201-amd64]#ll
总用量 25980
[root@localhost jdk1.8.0_201-amd64]#vim /etc/profile
#添加环境变量
export JAVA_HOME=/usr/java/jdk1.8.0_201-amd64
export CLASSPATH=$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar
export PATH=$JAVA_HOME/bin:$PATH
[root@localhost jdk1.8.0_201-amd64]#source /etc/profile
#刷新配置文件
[root@localhost tomcat]#tar zxvf apache-tomcat-9.0.16.tar.gz
[root@localhost tomcat]#cp -r apache-tomcat-9.0.16 /usr/local/tomcat
[root@localhost tomcat]#cd /usr/local/tomcat/
[root@localhost 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/java/jdk1.8.0_201-amd64
Using CLASSPATH: /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
Tomcat started.
[root@localhost ~]# /usr/local/tomcat/bin/shutdown.sh
#关闭服务
添加到
[root@localhost bin]#useradd -s /sbin/nologin tomcat
#新建用户
[root@localhost local]#chown tomcat:tomcat tomcat/ -R
#修改属主和属组
[root@localhost ~]#vim /etc/systemd/system/tomcat.service
#编写tomcat.service文件
[Unit]
Description=Tomcat
#After=syslog.target network.target remote-fs.target nss-lookup.target
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
~
[root@localhost local]#systemctl daemon-reload
[root@localhost local]#systemctl start tomcat
[root@localhost local]#ss -ntap |grep 8080
配置文件介绍及核心组件
配置文件
安装目录下 文件介绍
| 目录名字 | 功能 |
|---|---|
| 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 缓存的时候会使用到（升级版本时注意要删除里面的缓存） |
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日志系统相关的配置，可以修改日志级别和日志路径等 |
| 注意配置文件对于大小写敏感 |
核心组件
| 名称 | 说明 |
|---|---|
| server | 服务器，Tomcat运行的进程实例，一个Server中可以有多个service，但通常就一个 |
| service | 服务，用来组织Engine（引擎）和Connector（连接器，端口）的对应关系，一个service中只有一个Engine |
| connector | 连接器，负责客户端的HTTP、HTTPS、AJP等协议连接。一个Connector只属于某一个Engine |
| Engine | 即引擎，用来响应并处理用户请求。一个Engine上可以绑定多个Connector |
| Host | 即虚拟主机,可以实现多虚拟主机,例如使用不同的主机头区分 |
| Context | 应用的上下文，配置特定url路径映射和目录的映射关系: url => directory |
TIPS:
多实例：
多实例就是在一台服务器上同时开启多个不同的服务端口，同时运行多个服务进程，这些服务进程通过不同的socket监听不同的服务端口来提供服务。
引擎：
一般而言，引擎是一个程序或一套系统的支持部分。常见的程序引擎有游戏引擎、搜索引擎、杀毒引擎等
<?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">
<Context >
<Context />
</Host>
</Engine>
</Service>
</Server>
tomcat 处理请求过程
-
假设来自客户的请求为: http://localhost:8080/test/index.jsp
浏览器端的请求被发送到服务端端口8080，Tomcat进程监听在此端口上。通过侦听的HTTP/1.1Connector获得此请求。 -
Connector把该请求交给它所在的Service的Engine来处理，并等待Engine的响应
-
Engine获得请求localhost: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对象返回给浏览器端
/var/www/html/index.html
/var/www/html/test/index.html
/usr/loacl/tomcat/webapps
/usr/loacl/tomcat/webapps/ROOT/index.jsp
通常意义上的 Web 服务器接受请求后，只是单纯地响应静态资源，如 HTML 文件，图片
文件等，不能在后端进行一定的处理操作。 Tomcat 是 Apache 下的一个子项目，它具备 Web
服务器的所有功能，不仅可以监听接受请求并响应静态资源，而且可以在后端运行特定规范
的 Java 代码 Servlet，同时将执行的结果以 HTML 代码的形式反回客户端。
Tomcat 由一系列的组件构成，其中核心的组件有三个：
1）Web 容器：完成 Web 服务器的功能。（https请求）
2）Servlet 容器：名字为 catalina，用于处理 Servlet 代码。(具体的任务)
3）JSP 容器：用于将 JSP 动态网页翻译成 Servlet 代码。
① Web容器
负责底层的HTTP协议
② Servlet容器
由catalina脚本帮忙处理的servlet代码，主要处理后端逻辑业务
catalina实际处理的是Servlet代码，而Servlet代码是由Java编写的
③ JSP容器（JAVA Scripts page）
JSP：在正常的html标签中嵌入一些java代码
这些JSP最终会被翻译成Servlet代码被执行
主要提供提供前端页面展示<% %>
小结：tomcat就是一个容器，在这个容器中有三大核心组件：
WEB、Servlet 和JSP，所以Tomcat是极其轻量级别的，核心组件都是支持基本运行的组件
磁盘文件 和访问的url对应关系
apache：
/var/www/html/index.html -----> http://www.kgc.com/index.html
/var/www/html/test/index.html -----> http://www.kgc.com/test/index.html
tomcat:
/usr/local/tomcat/webapps
/usr/local/tomcat/webapps/ROOT/index.jsp -----> http://www.kgc.com/index.jsp
/usr/local/tomcat/webapps/test/index.jsp -----> http://www.kgc.com/test/index.jsp
http://192.168.91.103:8080/docs/
[root@localhost webapps]# cd /usr/local/tomcat/webapps
[root@localhost webapps]#mkdir blog
[root@localhost webapps]#vim blog/index.html
/usr/local/tomcat/webapps/blog/index.html
http://192.168.91.103:8080/blog/
主页文件的优先级
- index.html
- index.htm
- index.jsp
[root@localhost conf]#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>
[root@localhost blog]#chown tomcat:tomcat WEB-INF/ -R
打包jar包实际操作
jar包
war包
[root@localhost conf]#cd /data/
[root@localhost data]#ls
[root@localhost data]#mkdir app1
[root@localhost data]#cd app1/
[root@localhost app1]#ls
[root@localhost app1]#vim test.html
<h1> test </h1>
[root@localhost app1]#vim test.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<! DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jsp例子</title>
</head>
<body>
后面的内容是服务器端动态生成字符串，最后拼接在一起
<%
out.println ("test jsp");
%>
%<br>
<%=request.getRequestURL()%>
</body>
</html>
[root@localhost app1]#jar cvf /opt/app1.war *
#打包
[root@localhost opt]#cp app1.war /usr/local/tomcat/webapps/
[root@localhost opt]#ll /usr/local/tomcat/webapps/
http://192.168.91.103:8080/app1/test.jsp
http://192.168.91.103:8080/app1/test.html
#####下线只要删除war包直接自动删除
[root@localhost opt]#cd /opt
[root@localhost opt]#mv app1.war app1.war.zip
[root@localhost opt]#unzip app1.war.zip
Archive: app1.war.zip
creating: META-INF/
inflating: META-INF/MANIFEST.MF
inflating: test.html
inflating: test.jsp
[root@localhost opt]#ls
apache-tomcat-9.0.16.tar.gz META-INF nginx-1.12.0.tar.gz test.html
app1.war.zip nginx-1.12.0 rh test.jsp
未完成实验，连接数据库失败
[root@localhost ~]#vim /usr/local/tomcat/bin/catalina.sh
#设置一下这个文件一共7处
Djava.io.tmpdir="$CATALINA_TMPDIR"\
-Djava.awt.headless=true \
mysql> CREATE DATABASE blog; //创建一个数据库//
mysql> GRANT all ON blog.* TO 'bloguser'@'%' IDENTIFIED BY 'admin123'; //把bbs数据库里面所有表的权限授予给blogsuser,并设置密码//
mysql>flush privileges; //刷新数据库//
虚拟主机配置
可能有时候公司会有多个项目需要运行，那么肯定不可能是一台服务器上运行多个Tomcat 服务，这样会消耗太多的系统资源。此时，就需要使用到 Tomcat 虚拟主机。例如现在新增两个域名 www.kgc.com，www.accp.com希望通过这两个域名访问到不同的项目内容。
[root@localhost webapps]#mkdir kgc accp
[root@localhost webapps]#echo "this is kgc web !" > kgc/index.jsp
[root@localhost webapps]#echo "this is accp web !" > accp/index.jsp
[root@localhost webapps]#cat accp/index.jsp kgc/index.jsp
this is accp web ls
this is kgc web ls
#http://tomcat.apache.org/tomcat-8.5-doc/index.html
#配置文件的详解
[root@localhost ~]# vim /usr/local/tomcat/conf/server.xml
<Host name="www.kgc.com" appBase="/usr/local/tomcat/webapps"
unpackWARs="true" autoDeploy="true" xmlValidation="false" xmlNamespaceAware="false">
<Context docBase="/usr/local/tomcat/webapps/kgc" path="" reloadable="true" />
</Host>
<Host name="www.accp.com" appBase="/usr/local/tomcat/webapps"
unpackWARs="true" autoDeploy="true" xmlValidation="false"
xmlNamespaceAware="false">
<Context docBase="/usr/local/tomcat/webapps/accp"
path="" reloadable="true" />
</Host>
[root@localhost ~]#systemctl restart tomcat
##更改hosts文件## C:\Windows\System32\drivers\etc 改hosts文件
192.168.91.103 www.kgc.com www.accp.com
http://www.kgc.com:8080/kgc/
http://www.kgc.com:8080/accp/
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 首页，会有图片和静态资源文件，所以这里启用压缩。
以上是一些常用的配置参数，还有好多其它的参数设置，还可以继续深入的优化，HTTP
Connector 与 AJP Connector 的参数属性值，可以参考官方文档的详细说明进行学习。链
接 地 址 http://tomcat.apache.org/tomcat-9.0-doc/config/http.html ， 下 面 开 始 对
Tomcat 配置文件优化进行前后的对比
<Connector port="8080" protocol="HTTP/11.1"
connectionTimeout="20000"
redirectPort="8443"
minSpareThreads="50"
enableLookups="false"
disableUploadTimeout="true"
acceptCount="300"
maxThreads="500"
processorCache="500"
URIEncoding="UTF-8"
compression="on"
compressionMinSize="2048"
compressableMimeType="text/html,text/xml,text/javascript,text/css,text/plain,image/gif,image /jpg,image/png"/>
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
