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计算机的网络通信模型

Tomcat进阶学习上篇

应用层

不同计算机上应用之间的通信，来解决通信双方数据传输的问题。或者说不同计算机上对应的应用进程之间的通信。支持的协议有：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请求处理过程

Tomcat进阶学习上篇

第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容器

Tomcat进阶学习上篇

1.3.2Tomcat Servlet容器处理过程

Tomcat进阶学习上篇

步骤说明：

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进阶学习上篇

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内部组件

Tomcat进阶学习上篇

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实例。

Tomcat进阶学习上篇

2）Catalina结构

Tomcat进阶学习上篇

整个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容器具有很好的灵活性。

Tomcat进阶学习上篇

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整体结构

<?xml version="1.0" encoding="UTF-8"?>
<!--
port：关闭服务器的监听端⼝
shutdown：关闭服务器的指令字符串
-->
<Server port="8005" shutdown="SHUTDOWN">
    <!-- 以⽇志形式输出服务器 、操作系统、JVM的版本信息 -->
    <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
    <!-- Security listener. Documentation at /docs/config/listeners.html
    <Listener className="org.apache.catalina.security.SecurityListener" />
    -->
    <!--APR library loader. Documentation at /docs/apr.html -->
    <!-- 加载（服务器启动） 和 销毁 （服务器停⽌） APR。 如果找不到APR库， 则会输出⽇志， 并
    不影响 Tomcat启动 -->
    <Listener className="org.apache.catalina.core.AprLifecycleListener"
              SSLEngine="on" />
    <!-- Prevent memory leaks due to use of particular java/javax APIs-->
    <!-- 避免JRE内存泄漏问题 -->
    <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
    <!-- 加载（服务器启动） 和 销毁（服务器停⽌） 全局命名服务 -->
    <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
    <!-- 在Context停⽌时重建 Executor 池中的线程， 以避免ThreadLocal 相关的内存泄漏 -->
    <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
    <!-- Global JNDI resources
    Documentation at /docs/jndi-resources-howto.html
    GlobalNamingResources 中定义了全局命名服务
    -->
    <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">
        ...
    </Service>
</Server>

2.1.2Service标签

<Server port="8005" shutdown="SHUTDOWN">
   ....
    <Service name="Catalina">
        <!--为Connector创建一个线程池-->
        <!--
        <Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
            maxThreads="150" minSpareThreads="4"/>
        -->
        <!--创建一个监听8080的连接器组件 -->
        <Connector port="8080" protocol="HTTP/1.1"
                   connectionTimeout="20000"
                   redirectPort="8443" />
        <!-- 创建连接池的连接器 -->
        <!--
        <Connector executor="tomcatThreadPool"
                   port="8080" protocol="HTTP/1.1"
                   connectionTimeout="20000"
                   redirectPort="8443" />
        -->

        <!-- 创建一个监听8009的ajp的connector -->
        <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />

        <!--创建引擎 管理 多个Host-->
        <Engine name="Catalina" defaultHost="localhost">
            <!--配置集群-->
            <!--
            <Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>
            -->
            <Realm className="org.apache.catalina.realm.LockOutRealm">
                <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
                       resourceName="UserDatabase"/>
            </Realm>

            <!--host来管理各个Servlet-->
            <Host name="localhost"  appBase="webapps"
                  unpackWARs="true" autoDeploy="true">
                <!--servlet-->
                <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
                       prefix="localhost_access_log" suffix=".txt"
                       pattern="%h %l %u %t "%r" %s %b" />

            </Host>
        </Engine>
    </Service>
</Server>

Service标签包括Executor 、Connector、Engine、Host等子标签。

Executor标签

    <Executor 
          name="commonThreadPool"  <!--指定当前线程的名字 相当于Id-->
          namePrefix="thread-exec-" <!-- namePrefix 给线程指定前缀名字 -->
          maxThreads="200"  <!--指定最大线程数 -->
          minSpareThreads="100" <!-- 指定核心线程数 -->
          maxIdleTime="60000" <!-- 指定线程空闲时间 超过该时间线程被自动销毁单位是毫秒 -->
          maxQueueSize="Integer.MAX_VALUE"  <!-- 阻塞队列的大小最大值 -->
          prestartminSpareThreads="false" <!--确定线程池时是否启动核心线程-->
          threadPriority="5" <!--线程中的优先级默认是5 取值范围是1到10 -->
          className="org.apache.catalina.core.StandardThreadExecutor" <!-- 自定义线程池类路径 -->
         />

Executor主要作用是来创建一个线程池，用于连接器Connector使用。

Connector标签

<Connector 
        port="8080" <!--监听的端口号--> 
        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

    <Connector port="8080"
           protocol="HTTP/1.1"
           executor="commonThreadPool"
           maxThreads="1000"
           minSpareThreads="100"
           acceptCount="1000"
           maxConnections="1000"
           connectionTimeout="20000"
           compression="on"  <!--是否压缩数据， on是开启压缩 off关闭-->
           compressionMinSize="2048" <!--压缩的最小容量-->
           disableUploadTimeout="true" <!--是否允许Servlet容器,正在执行使用一个较长的连接超时-->
           redirectPort="8443"
           URIEncoding="UTF-8" />

Engine 标签

    <Engine name="Catalina" defaultHost="localhost">
    ...
    </Engine>

name属性： ⽤于指定Engine 的名称， 默认为Catalina

defaultHost：默认使⽤的虚拟主机名称， 当客户端请求指向的主机⽆效时， 将交由默认的虚拟主机处

理， 默认为localhost。

Host标签

<Host name="localhost2"  appBase="webapps2"
      unpackWARs="true" autoDeploy="true">

     <!--用来指定日志配置文件地址 valve-->
    <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
           prefix="localhost_access_log" suffix=".txt"
           pattern="%h %l %u %t "%r" %s %b" />

</Host>

Host标签属于engine的子标签，主要配置虚拟主机的。默认可以配置多个，appBase假如不配置context默认访问ROOT文件下的应用。

name：用于指定虚拟主机。

appBase：对应的配置路径

unpackWARs：解压war包默认为true

autoDeploye：自动提交

Context 标签

<Context docBase="/Users/demo/web_demo" path="/web3"></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 = "<p1>404 Not Found</p1>";
        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

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>

    <dependency>
        <groupId>dom4j</groupId>
        <artifactId>dom4j</artifactId>
        <version>1.6.1</version>
    </dependency>
    <dependency>
        <groupId>jaxen</groupId>
        <artifactId>jaxen</artifactId>
        <version>1.1.6</version>
    </dependency>
</dependencies>

web.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app>

    <servlet>
        <servlet-name>myServlet</servlet-name>
        <servlet-class>com.tomcat.demo.servlet.MyServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>myServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

</web-app>

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 = "<H1>Hello Servlet</H1>";
        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<String, Servlet> 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<String, Servlet> 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整体的处理思路。