其他分享
首页 > 其他分享> > tomcat系统架构

tomcat系统架构

作者：互联网

TOMCAT 7新特性 

　　1 使用随机数去防止跨站脚本攻击。 

　　2 改变了安全认证中的jessionid的机制，防止session攻击。 

　　3 内存泄露的侦测和防止 

　　4 在war文件外使用别名去存储静态内容。 

　　TOMCAT 7的增强功能 

　　5 对Servlet 3.0,JSP 2.2和JSP-EL 2。2的支持 

　　6 更容易将Tomcat内嵌到应用去中去，比如JBoss 

　　7 异步日志记录 

 

一、架构

下面谈谈我对Tomcat架构的理解

 

总体架构：

1、面向组件架构

2、基于JMX

3、事件侦听

 

1）面向组件架构

 

tomcat代码看似很庞大，但从结构上看却很清晰和简单，它主要由一堆组件组成，如Server、Service、Connector等，并基于JMX管理这些组件，另外实现以上接口的组件也实现了代表生存期的接口Lifecycle，使其组件履行固定的生存期，在其整个生存期的过程中通过事件侦听LifecycleEvent实现扩展。Tomcat的核心类图如下所示：



 

Java高级架构——Tomcat源码解析之整体流程介绍

1、Catalina：与开始/关闭shell脚本交互的主类，因此如果要研究启动和关闭的过程，就从这个类开始看起。

 

2、Server：是整个Tomcat组件的容器，包含一个或多个Service。

 

3、Service：Service是包含Connector和Container的集合，Service用适当的Connector接收用户的请求，再发给相应的Container来处理。

 

4、Connector：实现某一协议的连接器，如默认的有实现HTTP、HTTPS、AJP协议的。

 

5、Container：可以理解为处理某类型请求的容器，处理的方式一般为把处理请求的处理器包装为Valve对象，并按一定顺序放入类型为Pipeline的管道里。Container有多种子类型：Engine、Host、Context和Wrapper，这几种子类型Container依次包含，处理不同粒度的请求。另外Container里包含一些基础服务，如Loader、Manager和Realm。

 

6、Engine：Engine包含Host和Context，接到请求后仍给相应的Host在相应的Context里处理。

 

7、Host：就是我们所理解的虚拟主机。

 

8、Context：就是我们所部属的具体Web应用的上下文，每个请求都在是相应的上下文里处理的

 

9、Wrapper：Wrapper是针对每个Servlet的Container，每个Servlet都有相应的Wrapper来管理。

 

可以看出Server、Service、Connector、Container、Engine、Host、Context和Wrapper这些核心组件的作用范围是逐层递减，并逐层包含。

 

 

下面就是些被Container所用的基础组件：

 

1、Loader：是被Container用来载入各种所需的Class。

2、Manager：是被Container用来管理Session池。

3、Realm：是用来处理安全里授权与认证。

分析完核心类后，再看看Tomcat启动的过程，Tomcat启动的时序图如下所示：



 

从上图可以看出，Tomcat启动分为init和start两个过程，核心组件都实现了Lifecycle接口，都需实现start方法，因此在start过程中就是从Server开始逐层调用子组件的start过程。

 

2）基于JMX

JMX（Java Management Extensions，即Java管理扩展）是一个为应用程序、设备、系统等植入管理功能的框架。

 

Tomcat会为每个组件进行注册过程，通过Registry管理起来，而Registry是基于JMX来实现的，因此在看组件的init和start过程实际上就是初始化MBean和触发MBean的start方法，会大量看到形如：

Registry.getRegistry(null, null).invoke(mbeans, "init", false);

Registry.getRegistry(null, null).invoke(mbeans, "start", false);

 

这样的代码，这实际上就是通过JMX管理各种组件的行为和生命期。

 

3）事件侦听

 

各个组件在其生命期中会有各种各样行为，而这些行为都有触发相应的事件，Tomcat就是通过侦听这些时间达到对这些行为进行扩展的目的。在看组件的init和start过程中会看到大量如：

 

lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);

 

这样的代码，这就是对某一类型事件的触发，如果你想在其中加入自己的行为，就只用注册相应类型的事件即可。

 

二、一次完整请求的里里外外

前几天分析了一下Tomcat的架构和启动过程，今天开始研究它的运转机制。Tomcat最本质就是个能运行JSP/Servlet的Web服务器 ，因此最典型的应用就是用户通过浏览器访问服务器，Tomcat接收到请求后转发给Servlet，由Servlet处理完后，把结果返回给客户端。今天就专门解析一下这么一个完整的请求的内部机理。

 

通过DEBUG，一路跟下来，发现Tomcat处理请求的核心过程是以下几点：

 

1、启动的时候启动预支持协议的Endpoint，Endpoint会起专门的线程监听相应协议的请求，默认的情况下，会启动JIoEndpoint，JIoEndpoint基于Java ServerSocket接收Http的请求

 

2、ServerSocket接收到客户端请求的Socket后，一路包装，并一路从Host一直传递到Wrapper，再请求到相应的Servlet

 

下面将重点解析以上两个过程。

 

 

通过以前的分析（Tomcat源码分析一）可知道当Tomcat启动的时候会启动Connector，此时Connector会通过ProtocolHandler把Endpoint启动起来。默认情况下，Tomcat会启动两种Connector，分别是Http协议和AJP协议的，依次对应Http11Protocol和AjpProtocol，两者都是启动JIoEndpoint。下面看看JIoEndpoint的start方法：

Java代码  收藏代码
  1. public void start()  
  2.         throws Exception {  
  3.         // Initialize socket if not done before  
  4.         if (!initialized) {  
  5.             init();  
  6.         }  
  7.         if (!running) {  
  8.             running = true;  
  9.             paused = false;  
  10.   
  11.             // Create worker collection  
  12.             if (executor == null) {  
  13.                 workers = new WorkerStack(maxThreads);  
  14.             }  
  15.   
  16.             // Start acceptor threads  
  17.             for (int i = 0; i < acceptorThreadCount; i++) {  
  18.                 Thread acceptorThread = new Thread(new Acceptor(), getName() + "-Acceptor-" + i);  
  19.                 acceptorThread.setPriority(threadPriority);  
  20.                 acceptorThread.setDaemon(daemon);  
  21.                 acceptorThread.start();  
  22.             }  
  23.         }  
  24.     }  

 以上代码很清晰地表示启动acceptorThreadCount个线程，每个线程由Acceptor代理，具体看看Acceptor的run方法：

Java代码  收藏代码
  1. protected class Acceptor implements Runnable {  
  2.   
  3.   
  4.         /** 
  5.          * The background thread that listens for incoming TCP/IP connections and 
  6.          * hands them off to an appropriate processor. 
  7.          */  
  8.         public void run() {  
  9.   
  10.             // Loop until we receive a shutdown command  
  11.             while (running) {  
  12.   
  13.                 // Loop if endpoint is paused  
  14.                 while (paused) {  
  15.                     try {  
  16.                         Thread.sleep(1000);  
  17.                     } catch (InterruptedException e) {  
  18.                         // Ignore  
  19.                     }  
  20.                 }  
  21.   
  22.                 // Accept the next incoming connection from the server socket  
  23.                 try {  
  24.                     Socket socket = serverSocketFactory.acceptSocket(serverSocket);  
  25.                     serverSocketFactory.initSocket(socket);  
  26.                     // Hand this socket off to an appropriate processor  
  27.                     if (!processSocket(socket)) {  
  28.                         // Close socket right away  
  29.                         try {  
  30.                             socket.close();  
  31.                         } catch (IOException e) {  
  32.                             // Ignore  
  33.                         }  
  34.                     }  
  35.                 }catch ( IOException x ) {  
  36.                     if ( running ) log.error(sm.getString("endpoint.accept.fail"), x);  
  37.                 } catch (Throwable t) {  
  38.                     log.error(sm.getString("endpoint.accept.fail"), t);  
  39.                 }  
  40.   
  41.                 // The processor will recycle itself when it finishes  
  42.   
  43.             }  
  44.   
  45.         }  
  46.   
  47.     }  

 由此可得到这么一个结论：Tomcat就是通过ServerSocket监听Socket的方式来接收客户端请求的。找到处理请求的源头后下面要做的是事情就简单了，打好断点，在浏览器里请求一个最简单的Hello world，一路debug下去。一路跟下来，主流程的时序图如下所示：



 

从上图可知，以上过程可分解成以下三个最主要的核心点：

 

1、基于Http1.1协议对Socket的解析和包装

2、StandardEngineValve、StandardHostValve、StandardContextValve和StandardWrapperValve四种Valve的一路inoke。四种不同层次的Valve做了不同层次的处理和封装

3、基于责任链模式ApplicationFilterChain实现Filter拦截和实际Servlet的请求

 

 

以上三个核心点都是内容非常丰富的可研究点，会在以后几天逐一进行剖析。

 

一、Tomcat顶层架构

先上一张Tomcat的顶层结构图（图A），如下：


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

 

Service主要包含两个部分：Connector和Container。从上图中可以看出 Tomcat 的心脏就是这两个组件，他们的作用如下：

 

1、Connector用于处理连接相关的事情，并提供Socket与Request和Response相关的转化; 

2、Container用于封装和管理Servlet，以及具体处理Request请求；

 

一个Tomcat中只有一个Server，一个Server可以包含多个Service，一个Service只有一个Container，但是可以有多个Connectors，这是因为一个服务可以有多个连接，如同时提供Http和Https链接，也可以提供向相同协议不同端口的连接,示意图如下（Engine、Host、Context下边会说到）：


 多个 Connector 和一个 Container 就形成了一个 Service，有了 Service 就可以对外提供服务了，但是 Service 还要一个生存的环境，必须要有人能够给她生命、掌握其生死大权，那就非 Server 莫属了！所以整个 Tomcat 的生命周期由 Server 控制。

 

另外，上述的包含关系或者说是父子关系，都可以在tomcat的conf目录下的server.xml配置文件中看出，下图是删除了注释内容之后的一个完整的server.xml配置文件（Tomcat版本为8.0）



 上边的配置文件，还可以通过下边的一张结构图更清楚的理解：


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

 

二、Tomcat顶层架构小结：

 

（1）Tomcat中只有一个Server，一个Server可以有多个Service，一个Service可以有多个Connector（http1.1、AJP1.3）和一个Container；

（2） Server掌管着整个Tomcat的生死大权；

（4）Service 是对外提供服务的；

（5）Connector用于接受请求并将请求封装成Request和Response来具体处理；

（6）Container用于封装和管理Servlet，以及具体处理request请求；

 

知道了整个Tomcat顶层的分层架构和各个组件之间的关系以及作用，对于绝大多数的开发人员来说Server和Service对我们来说确实很远，而我们开发中绝大部分进行配置的内容是属于Connector和Container的，所以接下来介绍一下Connector和Container。

 

三、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既然处理请求，那么肯定需要先接收到这个请求，接收请求这个东西我们首先就需要看一下Connector！

 

四、Connector架构分析

 

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

 

因此，我们可以把Connector分为四个方面进行理解：

 

（1）Connector如何接受请求的？

（2）如何将请求封装成Request和Response的？

（3）封装完之后的Request和Response如何交给Container进行处理的？

（4）Container处理完之后如何交给Connector并返回给客户端的？

 

首先看一下Connector的结构图（图B），如下所示：


 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进行处理。

 

至此，我们应该很轻松的回答（1）（2）（3）的问题了，但是（4）还是不知道，那么我们就来看一下Container是如何进行处理的以及处理完之后是如何将处理完的结果返回给Connector的？

 

五、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.baidu.com,如果是Host（webapps）下的其他应用，则可以使用www.baidu.com/docs进行访问，当然默认指定的根应用（ROOT）是可以进行设定的，只不过Host站点下默认的主营用是ROOT目录下的。

 

看到这里我们知道Container是什么，但是还是不知道Container是如何进行处理的以及处理完之后是如何将处理完的结果返回给Connector的？别急！下边就开始探讨一下Container是如何进行处理的！

 

六、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的方式将结果返回给客户端。

 

总结

标签：Container,tomcat,Tomcat,处理,Service,系统,Connector,架构,请求
来源： https://www.cnblogs.com/hanease/p/15894178.html