1、Tomcat原理理论介绍
1.1 Tomcat简介
Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。对于一个初学者来说，可以这样认为，当在一台机器上配置好Apache 服务器，可利用它响应HTML（标准通用标记语言下的一个应用）页面的访问请求。实际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的。
1.1.1Tomcat目录结构
目录说明bin主要存放编译后的代码的地方，startup.bat、shutdown.bat分别对应windows版本的启动和关闭conf主要存放配置文件目录，context.xml 存放上下文的配置信息，logging.properties存放日志配置信息，server.xml指定服务端的一些配置信息比如端口号，web.xml指定一些Servlet的配置文件lib存储一些依赖的jar包（tomcat也是java开发的）Logs存放日志相关的包temp存放一些临时文件的包webapps主要存放解压之后的war的项目信息Work工作相关的信息
1.2 请求处理流程
1.2.1计算机的网络通信模型
应用层
不同计算机上应用之间的通信，来解决通信双方数据传输的问题。或者说不同计算机上对应的应用进程之间的通信。支持的协议有：HTTP FTP TFTP SMTP SNMP DNS TELNET HTTPS DHCP等。（协议）
表示层
用来规定传输的数据格式以及加解密，格式有，JPEG、ASCll、DECOIC、加密格式等。【在四层模型里面已经合并到了应用层】
会话层
用来规定开始、控制和终止一个会话。对应主机的进程，指本地主机与远程主机正在进行的会话。【在四层模型里面已经合并到了应用层】
传输层
规定传输数据的协议端口号，以及流控和差错校验。支持的协议有：TCP UDP等，数据包一旦离开网卡即进入网络传输层。指定IO模型 BIO NIO AIO等
网络层
进行逻辑地址寻址，实现不同网络之间的路径选择。（路由选择） 协议有：ICMP IGMP IP（IPV4 IPV6） ARP RARP。
数据链路层
建立逻辑连接、进行硬件地址寻址、差错校验等功能。（由底层网络定义协议，ATM，FDDI等）将比特组合成字节进而组合成帧，用MAC地址访问介质，能错误发现但不能纠正。
物理层
建立、维护、断开物理连接。（由底层网络定义协议，RJ45，802.3等）【在四层模型里面已经合并到了数据链路层】
1.2.2浏览器访问服务器流程
http请求处理过程
第2步是先建立连接，进行3次握手。
1.3 Tomcat 系统总体架构
1.3.1Tomcat处理请求大致流程
因为Tomcat可以处理Http请求，因此称Tomcat为Http服务器。
如果我们直接从浏览器发送请求，Tomcat直接接收请求，并将请求转发到对应的java程序的话，也可以实现请求处理，但是耦合度非常高，因此Tomcat的做法是在接收到http请求之后，将请求转发给servlet容器，由servlet容器在进行处理并转发到对应的java程序。
因此在Tomcat内部也实现了Servlet规范。（Servlet接⼝和Servlet容器这⼀整套内容叫作Servlet规范。）
因此Tomcat有两个身份：
1、Http服务器
2、Servlet容器
1.3.2Tomcat Servlet容器处理过程
步骤说明：
1）Tomcat中Http服务器模块会接收到原始的请求参数Request，封装ServletRequest准备请求Servlet容器
2）将请求转发到Servlet容器中定位Servlet（URL和Servlet的映射关系，找到相应的Servlet）
3）如果Servlet还未加载，利用反射机制创建Servlet，并调用Servlet的init初始化方法
4）获取到具体的Servlet实例之后直接调用对应的业务处理方法执行业务
5）将处理好的响应结果封装成ServletResponse
6）Http服务器在将ServletResponse对象封装成原生的Response相应到浏览器
1.3.3Tomcat系统总体架构总结
Tomcat中包括两大核心组件：
连接器（Connector）组件，容器（Container）组件。（还包括其他组件）
连接器（Connector）组件主要作用：处理Socket连接，负责⽹络字节流与Request和Response对象的转化。【与客户端交互】
容器（Container）组件主要作用：加载和管理Servlet，处理Request请求；
1.4Tomcat组件
1.4.1连接器组件 Coyote
1）Coyote简介
Coyote是Tomcat中连接器的组件名称，是对应的接口。客户端通过Coyote与服务器建立连接、发送请求并接受响应。
2）主要职责
1）Coyote封装了底层网络通信（Socket请求及相应处理）
2）Coyote使Container容器组件与具体的请求协议及IO操作⽅式完全解耦
3）Coyote将Socket输入转换封装为Request对象，并进一步封装成ServletRequest交给Container容器进行处理，处理完成后返回ServletResponse给Coyote，Coyote将对象转换成Response对象将结果写入输出流。
4）Coyote负责的是具体协议（应⽤层）和IO（传输层）相关内容。
3）Tomcat Coyote支持的IO模型与协议
支持的协议
应用层应用层描述描述HTTP/1.1大部分Web应用采用的协议【Tomcat8.x默认协议】AJPAJP定向包协议，实现对静态资源的优化以及集群的部署。HTTP/2HTTP2.0大幅度提升了web性能，属于下一代的HTTP协议但是用的很少。
支持的IO
传输层IO模型描述NIO同步非阻塞I/O、采用javaNIO类库实现【Tomcat8默认IO模型】NIO2异步非阻塞I/O、采用jdk7的NIO类库实现APR采用Apache可移植运行库实现，是C/C++编写的本地库，如果使用需要单独安装APR库。
Tomcat在8.0之前默认使用的是BIO。如果使用APR性能可能达到Apache Http Server的性能。
4）Coyote内部组件
Coyote组件其中包括EndPoint组件、Processor组件、Adapter组件。
EndPoint：EndPoint 是 Coyote 通信端点，即通信监听的接⼝，是具体Socket接收和发送处理器，是对传输层的抽象，因此EndPoint⽤来实现TCP/IP协议的。
Processor：Processor 是Coyote 协议处理接⼝，如果说EndPoint是⽤来实现TCP/IP协议的，那么Processor⽤来实现HTTP协议，Processor接收来⾃EndPoint的Socket，读取字节流解析成Tomcat的 Request和Response原生对象。
Adapter：Tomcat Request对象不是标准的ServletRequest，不能⽤Tomcat Request作为参数来调⽤容器。Tomcat设计者的解决⽅案是引⼊CoyoteAdapter，将参数转换成ServlerRequest对象。
ProtocolHandler：由Endpoint 和 Processor组成，Tomcat 按照协议和I/O 提供了6个实现类 ： AjpNioProtocol，AjpAprProtocol，AjpNio2Protocol，Http11NioProtocol，Http11Nio2Protocol，Http11AprProtocol。
1.4.2Tomcat Catalina组件
1）Catalina组件地位
本来Catalina组件只是Servlet容器的一个组件，而Tomcat是由一些列组件组成，组件可以在conf/server.xml文件中配置。Catalina在Tomcat中的地位非常的核心，因此经常把tomcat的一个实例当作一个Catalina实例。
2）Catalina结构
整个Tomcat就相当于一个Catalina实例，Tomcat启动的时候会先初始化这个实例Catalina，Catalina实例对象通过加载server.xml完成其他实例的创建，创建并管理⼀个Server，Server创建并管理多个服务，每个服务⼜可以有多个Connector和⼀个Container。
对应关系：一个Tomcat对应一个Catalina，对应一个Server，对应多个Service。每一个Service实例有多个Connector和一个Container实例。
Catalina：负责解析Tomcat的配置⽂件（server.xml） , 以此来创建服务器Server组件并进⾏管理
Server：Server是整个Catalina Servlet容器以及其它组件，作用负责组装并启动Servlaet引擎,Tomcat连接器。Server通过实现Lifecycle接⼝，提供了⼀种优雅的启动和关闭整个系统的⽅式。
Service：Service是Server内部的组件，⼀个Server包含多个Service。它将若⼲个Connector组件绑定到⼀个Container。
Container：容器，负责处理⽤户的servlet请求，并返回对象给web⽤户的模块。
3）Container 组件介绍
Container组件其中包括Engine、Host、Context、Wrapper4种组件，他们之间是父子关系。Tomcat通过分层的架构，让Servlet容器具有很好的灵活性。
Engine：表示整个Servlet容器的引擎，用来管理多个虚拟站点，一个Service只能有一个Engine。
Host：代表一个虚拟主机，或者说一个站点，可以配置多个虚拟主机地址，一个Engine可以有多个Host。
Context：表示一个Web应用服务器，一个Host下可以包含多个Context。
Wrapper：表示一个Servlet， 一个Context中可以包括多个Wrapper。
2、Tomcat核心配置
思考：
去哪儿配置？->conf/server.xml中
怎么配置？
2.1server.xml配置详解
2.1.1server配置文件概述
server.xml中包括Server根标签，Listener，GlobalNamingResources，Service
Server标签：主要用来创建一个server实体对象
Listener标签：定义监听器
GlobalNamingResources 标签：定义服务器的全局JNDI（Java Naming and Directory Interface 标准的Java命名系统接口）资源。
Service标签：定义⼀个Service服务，⼀个Server标签可以有多个Service服务实例
Server.xml整体结构
...
2.1.2Service标签
....
Service标签包括Executor 、Connector、Engine、Host等子标签。
Executor标签
namePrefix="thread-exec-"
maxThreads="200"
minSpareThreads="100"
maxIdleTime="60000"
maxQueueSize="Integer.MAX_VALUE"
prestartminSpareThreads="false"
threadPriority="5"
className="org.apache.catalina.core.StandardThreadExecutor"
/>
Executor主要作用是来创建一个线程池，用于连接器Connector使用。
Connector标签
protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
protocol="HTTP/1.1": 当前Connector⽀持的访问协议。 默认为 HTTP/1.1 ，并采⽤⾃动切换机制选择⼀个基于 JAVANIO 的链接器或者基于本地APR的链接器（根据本地是否含有Tomcat的本地库判定）
redirectPort="8443"：当前Connector 不⽀持SSL请求， 接收到了⼀个请求， 并且也符合security-constraint 约束，需要SSL传输，Catalina⾃动将请求重定向到指定的端⼝。
URIEncoding="UTF-8"：⽤于指定编码URI的字符编码， Tomcat8.x版本默认的编码为 UTF-8 , Tomcat7.x版本默认为ISO-8859-1。
executor="commonThreadPool"：指定共享线程池的名称，也可以通过maxThreads、minSpareThreads 等属性配置内部线程池。
内部线程Demo
compressionMinSize="2048"
disableUploadTimeout="true"
redirectPort="8443"
URIEncoding="UTF-8" />
Engine 标签
...
name属性： ⽤于指定Engine 的名称， 默认为Catalina
defaultHost：默认使⽤的虚拟主机名称， 当客户端请求指向的主机⽆效时， 将交由默认的虚拟主机处
理， 默认为localhost。
Host标签
Host标签属于engine的子标签，主要配置虚拟主机的。默认可以配置多个，appBase假如不配置context默认访问ROOT文件下的应用。
name：用于指定虚拟主机。
appBase：对应的配置路径
unpackWARs：解压war包默认为true
autoDeploye：自动提交
Context 标签
Context属于Host的子标签，主要用来映射应用所在的文件，比如上边的访问uri是web3映射到 /Users/demo/web_demo文件夹下。
docBase：Web应⽤⽬录或者War包的部署路径。可以是绝对路径，也可以是相对于Host appBase的相对路径。
path：Web应⽤的Context 路径。如果我们Host名为localhost， 则该web应⽤访问的根路径为：localhost:8080/web3。
3、手写简易版本Tomcat
3.1分析
手写一个Tomcat名称叫做Minicat，需求：可以接收浏览器的http请求，并进行请求处理，处理之后将结果返回给浏览器客户端。
1）提供服务，接收请求（Socket通信）
2）请求信息封装成Request对象（Response对象）
3）客户端请求资源，资源分为静态资源和动态资源
4）将资源返回给客户端
3.2 V1版本Code
public class Bootstrap {
//自定义端口号
public static final int port = 8080;
//启动方法
private void start() throws IOException {
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("启动成功，端口号：" + port);
while (true) {
Socket accept = serverSocket.accept();
OutputStream outputStream = accept.getOutputStream();
String content = "Hello Word !";
String retResult = HttpProtocolUtil.getHeader200(content.getBytes().length) + content;
outputStream.write(retResult.getBytes());
outputStream.close();
}
}
public static void main(String[] args) {
Bootstrap bootstrap = new Bootstrap();
try {
bootstrap.start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
封装相应头工具类：
public class HttpProtocolUtil {
/**
* 获取200响应结果
*/
public static String getHeader200(int size){
return "HTTP/1.1 200 OK \n" +
"Content-Type: text/html \n" +
"Content-Length: " + size + " \n" +
"\r\n";
}
/**
* 获取404响应结果
*/
public static String getHeader404(){
String str404 = "404 Not Found ";
return "HTTP/1.1 404 Not Found \n" +
"Content-Type: text/html \n" +
"Content-Length: " + str404.length() + " \n" +
"\r\n" + str404;
}
}
总结：V1版本的代码比较简单，就是简单在页面上写输入一个8080返回一个Hello Minicat但是需要注意在返回结果中必须添加上html响应头信息浏览器才能显示
3.3 V2版本Code
要求：能够输出静态资源文件。
3.3.1 观察请求参数
private void start() throws IOException {
ServerSocket serverSocket = new ServerSocket(port);
while (true){
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
//防止网络波动读取不到参数
int count = 0;
while (count == 0) {
count = inputStream.available();
}
byte[] bytes = new byte[count];
inputStream.read(bytes);
System.out.println(new String(bytes));
socket.close();
}
}
打印的参数
GET / HTTP/1.1
Host: localhost:8080
Connection: keep-alive
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.122 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
只提取一些有用的请求信息，比如GET、/ 路径信息、参数信息。来封装成Request对象和Response对象。
3.3.2完成V2版本的Code
Bootstrap启动类
public class Bootstrap {
private static final int port = 8080;
public static void main(String[] args) {
Bootstrap bootstrap = new Bootstrap();
try {
bootstrap.start();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* V2.0版本
*/
private void start() throws IOException {
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("启动成功");
while (true){
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream();
//获取到输入输出对象
Request request = new Request(inputStream);
Response response = new Response(outputStream);
//将结果写到输出流中
response.outputHtml(request.getUrl());
//一定要把socket关闭
socket.close();
}
}
}
Request对象
@Data
@NoArgsConstructor
public class Request {
//请求方式GET、POST
private String methodType;
//请求URL
private String url;
//输入流
private InputStream inputStream;
/**
* 构造器
*/
public Request(InputStream inputStream) throws IOException {
this.inputStream = inputStream;
parseInputParam(inputStream);
}
//解析参数
private void parseInputParam(InputStream inputStream) throws IOException {
//只提取第一行
int length = 0;
while (length == 0){
length = inputStream.available();
}
byte[] bytes = new byte[length];
inputStream.read(bytes);
String inputStr = new String(bytes);
//截取出来 GET / HTTP/1.1
String[] split = inputStr.split("\\n");
String[] infoArr = split[0].split(" ");
this.methodType = infoArr[0];
this.url = infoArr[1];
System.out.println("=====>>method:" + methodType);
System.out.println("=====>>url:" + url);
}
}
Response响应对象
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Response {
private OutputStream outputStream;
//V2版本只输出静态资源文件
public void outputHtml(String path) throws IOException {
//获取到文件的绝对路径
String absolutePath = StaticResourceUtil.getAbsolutePath(path);
File file = new File(absolutePath);
if (file.exists() && file.isFile()) {
//调用工具类输出文件
StaticResourceUtil.outputStaticResource(new FileInputStream(file), outputStream);
}else{
//404 Not Found
output(HttpProtocolUtil.getHeader404());
}
}
//输出文件
private void output(String path) throws IOException {
outputStream.write(path.getBytes());
}
}
静态资源处理工具
public class StaticResourceUtil {
/**
* 获取到文件的绝对路径并且替换\\为/方便linux识别
*/
public static String getAbsolutePath(String path) {
//获取到当前的绝对路径
String absolutePath = StaticResourceUtil.class.getResource("/").getPath();
return (absolutePath + path).replaceAll("\\\\", "/");
}
/**
* 根据输入流 对文件进行输出
*
* @param inputStream 输入流
* @param outputStream 输出流
*/
public static void outputStaticResource(InputStream inputStream,
OutputStream outputStream) throws IOException {
//缓冲区
int buffer = 1024;
int actualOutSize = 0;
//获取需要输出文件流的长度
int outputSize = 0;
while (outputSize == 0){
outputSize = inputStream.available();
}
//输出请求头
outputStream.write(HttpProtocolUtil.getHeader200(outputSize).getBytes());
byte[] bytes = new byte[buffer];
while (actualOutSize < outputSize){
//如果最后不够一个缓冲区的话需要获取到最后的数据length
if (actualOutSize + buffer > outputSize) {
buffer = outputSize - actualOutSize;
bytes = new byte[buffer];
}
//从输入流中读取
inputStream.read(bytes);
//写出到输出流
outputStream.write(bytes);
//刷新输出流
outputStream.flush();
actualOutSize += buffer;
}
}
}
总结： 底层使用的是JavaSocket编程，就是对应输入和输出流进行了封装，截取了需要的信息。
3.4 V3版本Code
需求，能够接收静态和动态资源，使用线程池接收。
基于V2版本Request和Response进行开发。
添加Pom Dom4j用来配置servlet
org.projectlombok
lombok
1.18.12
dom4j
dom4j
1.6.1
jaxen
jaxen
1.1.6
web.xml配置文件
myServlet
com.tomcat.demo.servlet.MyServlet
myServlet
/hello
Servlet
public interface Servlet {
//初始化
void init() throws Exception;
//销毁
void destroy() throws Exception;
//执行请求
void service(Request request, Response response) throws Exception;
}
public abstract class HttpServlet implements Servlet {
public abstract void doGet(Request request, Response response)throws Exception;
public abstract void doPost(Request request, Response response)throws Exception;
@Override
public void service(Request request, Response response) throws Exception {
if ("GET".equalsIgnoreCase(request.getMethodType())) {
doGet(request,response);
}else {
doPost(request,response);
}
}
}
public class MyServlet extends HttpServlet {
@Override
public void doGet(Request request, Response response) throws Exception {
doPost(request,response);
}
@Override
public void doPost(Request request, Response response) throws Exception {
String content = "Hello Servlet
";
String header200 = HttpProtocolUtil.getHeader200(content.getBytes().length);
response.output(header200 + content);
}
@Override
public void init() throws Exception {
System.out.println("初始化方法...");
}
@Override
public void destroy() throws Exception {
System.out.println("销毁方法...");
}
}
BootStrap启动类
public class Bootstrap {
private static final int port = 8080;
private Map servletMap = new HashMap<>();
public static void main(String[] args) {
Bootstrap bootstrap = new Bootstrap();
try {
bootstrap.start();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 启动tomcat
*/
private void start() throws IOException {
ServerSocket serverSocket = new ServerSocket(port);
//解析web.xml
parseWebXml();
//创建一个线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
20,//指定核心线程数
100,//指定最大线程数
100L,//指定存活时间
TimeUnit.MILLISECONDS,//指定时间格式
new LinkedBlockingDeque<>(1000));//设置阻塞队列大小
while (true){
//获取到socket
Socket socket = serverSocket.accept();
//通过线程池去执行
threadPool.execute(new RequestProcessor(socket, servletMap));
}
}
private void parseWebXml() {
try {
InputStream resourceAsStream = this.getClass().getResourceAsStream("/web-apps/WEB-INF/web.xml");
Document document = new SAXReader().read(resourceAsStream);
Element rootElement = document.getRootElement();
Element servletElement = (Element) rootElement.selectSingleNode("servlet");
String servletName = servletElement.selectSingleNode("servlet-name").getStringValue();
String servletClass = servletElement.selectSingleNode("servlet-class").getStringValue();
Element servletMapping = (Element) rootElement.selectSingleNode("servlet-mapping[servlet-name = '" + servletName + "']");
String urlPattern = servletMapping.selectSingleNode("url-pattern").getStringValue();
servletMap.put(urlPattern, (Servlet) Class.forName(servletClass).newInstance());
} catch (Exception e) {
e.printStackTrace();
}
}
}
RequestProcessor请求处理类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RequestProcessor implements Runnable {
private Socket socket;
private Map servletMap;
@Override
public void run() {
try {
InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream();
Request request = new Request(inputStream);
Response response = new Response(outputStream);
//动态资源
if (servletMap.containsKey(request.getUrl())) {
servletMap.get(request.getUrl()).service(request, response);
}else {
//静态资源
response.outputHtml(request.getUrl());
}
//关闭当前socket
socket.close();
}catch (Exception e){
e.printStackTrace();
}
}
}
总结：书写Mini版本的Tomcat感受一下Tomcat整体的处理思路。