一、TOMCAT的基本架构

1、servlet基本架构

由servlet容器加载servlet类，决定调用哪个servlet也就是业务类。整体遵守的就是servlet规范。

2、Servlet容器工作流程

当请求由http服务器转发给Servlet容器后，servlet会根据url的映射关系，定位到servlet。

• 定位servlet
• 加载servlet
• 调用servlet

3、tomcat架构

两部分核心：

1. 处理socket连接，负责处理网络请求 - Connector
2. 加载和管理servlet，以及处理request请求 - Container

二、Coyote连接器

1、Coyote

Coyote作为独立的模块，只负责集体协议和IO操作，与Servlet规范没有直接关系，因此Request和Response也与Servlet没有关系。这样就做到了组件之间的解藕。

支持的IO模型：

• NIO：非阻塞IO，采用java NIO类库实现
• NIO2：一步IO，采用JDK7最新的NIO2类库实现
• APR：采用apache的可以值类库实现

支持的应用层协议：

• HTTP1.1：这是大部分web采用的访问协议
• AJP：用于和Web服务器即成，以实现对静态资源的优化和集群部署
• HTTP2：下一代HTTP协议，性能大幅度提升

tomact容器支持多种IO模型和应用层模型。每个容器可以连接多个Coyote。所以一个coyote+catalina才能对外提供服务，也就是一个service。

2、Coyote组件的架构

1. EndPoint：接受socket请求，发送给Processor
2. Processor：将socket请求，封装为http请求，request转发给Adapter
3. Adapter：由适配器将request对象封装成servletRequest转发给容器
4. ProtocolHandler： EndPoint+Processor

三、Catalina容器

1、Catalina容器

Catalina是Tomcat的servlet容器。包含了后面涉及到的安全、会话、集群、管理的Servlet容器架构的各个方面。

Tomcat本身就是一个servlet容器，所以Catalina就是tomcat的核心。其它的模块都是为Catalina容器进行提供服务的。 

2、Catalina结构

• Catalina：负责解析Tomcat配置文件，以此来创建服务器Server组件，并根据命令管理
• Server：表示整个Catalina Servlet容器及其它组件，负责启动Servlet引擎，tomcat连接器
  • Service：将Connector和Container绑定到一期
    • Connector：连接器
    • Container：servlet容器

3、Container结构

Container包含了Engine、Host、Context、Wapper，它们不是平行关系，而是父子关系。

• Engine：表示整个Catalina的Servlet的引擎，一个Service只能包含一个Engine
• Host：代表一个虚拟主机或者一个站点，可以个给Tomcat配置多个虚拟主机
• Context：代表一个web应用，一个应用可以有多个Context
• Wapper： 代表一个Servlet

其实在server.xml中就包含了以上的各个组件和它们之间的关系。

四、启动流程介绍

父组件启动同时调用子组件的启动方法。记载tomcat的配置文件，初始化容器组件，监听对应的端口号，准备接受客户端请求。

在tomcat，所有的功能都被抽象成组件，他们都有一个统一的接口，就是Lifecycle接口，它的核心方法有：

• init()：初始化组件
• start()：启动组件
• stop()：停止组件
• destroy()：销毁组件

个组件默认实现如下：

五、请求处理流程介绍

1、请求处理流程

tomcat是使用mapper组件，进行请求的映射。可以看成是一个多层次的map。

六、Jasper引擎

1、简介

主要作用就是解析jsp页面，然后生成class字节码，向浏览器输出HTML。由于使用的越来越少了，在这里就不进行过多介绍。

2、编译方式

• 运行时编译：请求第一次的时候，进行编译
• 预编译：启动项目的时候，直接编译完成

七、服务器配置

1、核心配置文件server.xml

是tomcat服务器的核心配置文件，包含了tomcat中servlet（Catalina）容器的全部配置。

• Server：根标签，配置关闭端口，配置相关的监听器、全局命名和多个Service
• Service：服务名字就是Catalina，可以配置多个连接器、一个Engine
• Executor：配置tomcat线程池相关内容，如果配置则多个连接器使用一个，否则每个连接器使用自己的线程池
• Connector：连接器，可以配置port、protocol、conectionTimeout、redirectProt(https)、executor、encoding
• Engine：name、defaultHost（默认主机）、jvm（使用的虚拟机）
• Host：name、appBase（部署路径）、unpackWARs（是否解压WAR包）、autoDeploy（是否自动部署）
• Context：虚拟主机中的项目

Tomcat顶层架构

Tomcat的顶层结构图：

1、Tomcat中最顶层的容器是Server，代表着整个服务器，一个Server可以包含至少一个Service，用于具体提供服务。

2、Service主要包含两个部分：Connector和Container。 Tomcat 的心脏就是这两个组件，这两个组件的作用：Connector用于处理连接相关的事情，并提供Socket与Request和Response相关的转化;Container用于封装和管理Servlet，以及具体处理Request请求。

3、一个Tomcat中只有一个Server，一个Server可以包含多个Service，一个Service只有一个Container，但是可以有多个Connectors，因为一个服务可以有多个连接，如同时提供Http和Https链接，也可以提供向相同协议不同端口的连接。

4、多个 Connector 和一个 Container 就形成了一个 Service，有了 Service 就可以对外提供服务了，但是 Service 还要一个生存的环境，必须要有人能够给她生命、掌握其生死大权，那就非 Server 莫属了！所以整个 Tomcat 的生命周期由 Server 控制。另外，上述的包含关系或者说是父子关系，都可以在tomcat的conf目录下的server.xml配置文件中看出。

5、Server标签设置的端口号为8005，shutdown=”SHUTDOWN” ，表示在8005端口监听“SHUTDOWN”命令，如果接收到了就会关闭Tomcat。一个Server有一个Service，当然还可以进行配置，一个Service有多个，Service左边的内容都属于Container的，Service下边是Connector。

Server处理HTTP请求

原理图

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的默认主机），名为localhost的Host获得请求/test/index.jsp，匹配它所拥有的所有Context。Host匹配到路径为/test的Context（如果匹配不到就把该请求交给路径名为“ ”的Context去处理）；

5.path=“/test”的Context获得请求/index.jsp，在它的mapping table中寻找出对应的Servlet。Context匹配到URL Pattern为*.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。

Connector架构分析

Connector用于接受请求并将请求封装成Request和Response，然后交给Container进行处理，Container处理完之后在交给Connector返回给客户端。Connector的结构图：

Connector就是使用ProtocolHandler来处理请求的，不同的ProtocolHandler代表不同的连接类型，比如：Http11Protocol使用的是普通Socket来连接的，Http11NioProtocol使用的是NioSocket来连接的。其中ProtocolHandler由包含了三个部件：Endpoint、Processor、Adapter：

（1）Endpoint用来处理底层Socket的网络连接，Processor用于将Endpoint接收到的Socket封装成Request，Adapter用于将Request交给Container进行具体的处理。

（2）Endpoint由于是处理底层的Socket网络连接，因此Endpoint是用来实现TCP/IP协议的，而Processor用来实现HTTP协议的，Adapter将请求适配到Servlet容器进行具体的处理。

（3）Endpoint的抽象实现AbstractEndpoint里面定义的Acceptor和AsyncTimeout两个内部类和一个Handler接口。Acceptor用于监听请求，AsyncTimeout用于检查异步Request的超时，Handler用于处理接收到的Socket，在内部调用Processor进行处理。

Container架构分析

Container用于封装和管理Servlet，以及具体处理Request请求，在Connector内部包含了4个子容器，结构图如下（图C）：

4个子容器的作用分别是：

（1）Engine：引擎，用来管理多个站点，一个Service最多只能有一个Engine；
（2）Host：代表一个站点，也可以叫虚拟主机，通过配置Host就可以添加站点；
（3）Context：代表一个应用程序，对应着平时开发的一套程序，或者一个WEB-INF目录以及下面的web.xml文件；
（4）Wrapper：每一Wrapper封装着一个Servlet；

下面找一个Tomcat的文件目录对照一下，如下图所示：

Context和Host的区别是Context表示一个应用，我们的Tomcat中默认的配置下webapps下的每一个文件夹目录都是一个Context，其中ROOT目录中存放着主应用，其他目录存放着子应用，而整个webapps就是一个Host站点。

我们访问应用Context的时候，如果是ROOT下的则直接使用域名就可以访问，例如：www.hern.com,如果是Host（webapps）下的其他应用，则可以使用http://www.hern.com/docs进行访问，当然默认指定的根应用（ROOT）是可以进行设定的，只不过Host站点下默认的主营用是ROOT目录下的。

Container处理请求

 Container处理请求是使用Pipeline-Valve管道来处理的！（Valve是阀门之意）Pipeline-Valve是责任链模式，责任链模式是指在一个请求处理的过程中有很多处理者依次对请求进行处理，每个处理者负责做自己相应的处理，处理完之后将处理后的请求返回，再让下一个处理着继续处理。但是Pipeline-Valve使用的责任链模式和普通的责任链模式有些不同，区别主要有以下两点：

（1）每个Pipeline都有特定的Valve，而且是在管道的最后一个执行，这个Valve叫做BaseValve，BaseValve是不可删除的；

（2）在上层容器的管道的BaseValve中会调用下层容器的管道。

Container包含四个子容器，而这四个子容器对应的BaseValve分别在：StandardEngineValve、StandardHostValve、StandardContextValve、StandardWrapperValve。

Pipeline的处理流程图如下（图D）：

（1）Connector在接收到请求后会首先调用最顶层容器的Pipeline来处理，这里的最顶层容器的Pipeline就是EnginePipeline（Engine的管道）；

（2）在Engine的管道中依次会执行EngineValve1、EngineValve2等等，最后会执行StandardEngineValve，在StandardEngineValve中会调用Host管道，然后再依次执行Host的HostValve1、HostValve2等，最后在执行StandardHostValve，然后再依次调用Context的管道和Wrapper的管道，最后执行到StandardWrapperValve。

（3）当执行到StandardWrapperValve的时候，会在StandardWrapperValve中创建FilterChain，并调用其doFilter方法来处理请求，这个FilterChain包含着我们配置的与请求相匹配的Filter和Servlet，其doFilter方法会依次调用所有的Filter的doFilter方法和Servlet的service方法，这样请求就得到了处理！

（4）当所有的Pipeline-Valve都执行完之后，并且处理完了具体的请求，这个时候就可以将返回的结果交给Connector了，Connector在通过Socket的方式将结果返回给客户端。

Connector和Container的微妙关系

当一个请求发送到Tomcat之后，首先经过Service然后会交给Connector，Connector用于接收请求并将接收的请求封装为Request和Response来具体处理，Request和Response封装完之后再交由Container进行处理，Container处理完请求之后再返回给Connector，最后在由Connector通过Socket将处理的结果返回给客户端，这样整个请求的就处理完了！

Connector最底层使用的是Socket来进行连接的，Request和Response是按照HTTP协议来封装的，所以Connector同时需要实现TCP/IP协议和HTTP协议！

Tomcat顶层架构小结

（1）Tomcat中只有一个Server，一个Server可以有多个Service，一个Service可以有多个Connector和一个Container；
（2） Server掌管着整个Tomcat的生死大权；
（4）Service 是对外提供服务的；
（5）Connector用于接受请求并将请求封装成Request和Response来具体处理；
（6）Container用于封装和管理Servlet，以及具体处理request请求；

1.嵌入式Tomcat

懂得SpringBoot的童鞋应该很清楚，对于SpringBoot应用来说，不管应用程序是属于何种类型，都是一个Main方法走遍天下，而且对于web应用，只需要引入spring-boot-starter-web中这个依赖，应用程序就好像直接给我们来了个tomcat一样，其实，这里并不是SpringBoot团队里面有什么骚操作，而是Tomcat本身提供的外部接口，使其它应用程序能够非常方便的将Tomca嵌入t到自身的应用来。
对于嵌入式Tomcat，其实也非常简单，就是调用Tomcat提供的外部类org.apache.catalina.startup.Tomcat而已，下面，我们通过代码来简单描述一下，如何在我们自身的程序嵌入Tomcat。
maven依赖

  <dependency>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
  </dependency>

简单的一个servlet

public class DemoServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    @Override
    public void doGet(HttpServletRequest request,
                      HttpServletResponse response)
            throws IOException, ServletException {
        response.setContentType("text/html");
        response.setCharacterEncoding("UTF-8");
        PrintWriter out = response.getWriter();

        out.println("<!DOCTYPE html><html>");
        out.println("<head>");
        out.println("<meta charset="UTF-8" />");
        out.println("<title></title>");
        out.println("</head>");
        out.println("<body bgcolor="white">");
        out.println("<h1> 嵌入式tomcat</h1>");
        out.println("</body>");
        out.println("</html>");
    }
}

EmbeddedTomcatServer 嵌入式Tomat入口：

public class EmbeddedTomcatServer {
    public static void main(String[] args) throws Exception {
        //把目录的绝对的路径获取到
        String classpath = System.getProperty("user.dir");
        System.out.println(classpath);
        //new一个Tomcat
        Tomcat tomcat = new Tomcat();

        //插件是6或者6以前的
        //Embbedded
        //设置Tomcat的端口
        //tomcat.setPort(9090);
        Connector connector = tomcat.getConnector();
        connector.setPort(9091);
        //设置Host
        Host host = tomcat.getHost();
        //我们会根据xml配置文件来
        host.setName("localhost");
        host.setAppBase("webapps");
        //前面的那个步骤只是把Tomcat起起来了，但是没啥东西
        //要把class加载进来,把启动的工程加入进来了
        Context context = tomcat.addContext(host, "/", classpath);

        if (context instanceof StandardContext) {
            StandardContext standardContext = (StandardContext) context;
            standardContext.setDefaultContextXml("E:\apache-tomcat-8.5.51\conf\web.xml");
            //我们要把Servlet设置进去
            Wrapper wrapper = tomcat.addServlet("/", "DemoServlet", new DemoServlet());
            wrapper.addMapping("/embeddedTomcat");
        }
        //Tomcat跑起来
        tomcat.start();
        //强制Tomcat server等待，避免main线程执行结束后关闭
        tomcat.getServer().await();
    }

}

运行结果：

EmbeddedTomcatServer类作为程序的入口，代码逻辑其实就是通过tomcat提供的外部接口类在配置server.xml这个文件；要了解这个类的每个配置步骤，可能需要对tomcat相关组件有一定的理解，如下所示，对于每个组件的作用，博主画了一个图进行简单的介绍

对于Tomcat源码的构建，有兴趣的童鞋可参考这篇文章：https://www.jb51.net/article/95120.htm

2. Spring内嵌Tomcat原理剖析

其实SpringBoot嵌入Tomcat等其它web容器，关键是在类ServletWebServerApplicationContext的onRefresh方法，如下为该方法的代码定义：

继续进入createWebServer()方法

进入TomcatServletWebServerFactory#getWebServer()方法。如下所示

通过上面流程分析，可以发现，SpringBoot嵌入Tomcat也是通过调用Tomcat提供的外部类org.apache.catalina.startup.Tomcat进行开发的。