(精)tomcat 源码学习

Ne0inhk

25 Dec 2024 — 30 min read

Tomcat6是最新版本的web容器，其支持最新版本的servlet2.5和jsp2.1。而且Tomcat6架构也是经过重新设计优化过的，所以我们有必要分析一下它的架构过程。显然，这是一个通过阅读Tomcat的源代码及相关文档，演绎架构的过程。或许有人会说，这不是放马后炮吗？！！但我觉得这是自我进步的一个必经步骤，先模仿之，然后才能超越之，毕竟我本凡人。

Tomcat的架构总的来说是分层次的、可插拔的组件架构。分层次是指构成Tomcat的组件不是同一级别的，上层组件可以包含子组件，各个组件有其功能范围，当一个组件停止服务时，不会影响上层组件的服务。可插拔是指对于组件的添加和删除并不影响服务器的运行。那么为了达到可插拔的组件架构，分层次的组件架构必成为基础。

对于任何服务器，即使最简单的实现，从面向对象设计（OOD）的角度来说，我们都有必要将“服务器”这个概念抽象出来，为什么呢？因为只有有了这个概念，才能谈服务器的实例，服务器的功能等等其它概念，此之谓“皮之不存，毛将焉附”。赶巧（其实是我的想法恰好撞上人家的想法），Tomcat也将“服务器”抽象为java接口org.apache.catalina.Server，显然Server应该就是最最顶层的组件了。

有了Server这个抽象，很自然的，我们希望它能够提供对servlet和jsp支持的功能。但是我们发现这个概念太大了，我们还需再细化。所以别急，我们还有一些事情要解决。服务器要提供服务就必须能够启动，当然也应该能够停止吧，也就是说服务器应该是有生命的，在启动时初始化必要的资源，而在停止时将其其销毁掉。好吧，我们把这个也抽象出来，叫做生命周期接口，tomcat 实现为org.apache.catalina.Lifecycle.如上所述我们知道Lifecycle需要完成的工作了。

public void start() throws LifecycleException;

public void stop() throws LifecycleException;

接下来我们分析服务器如何来处理客户端的请求，一般的我们会在浏览器中输入如下格式的请求，。对于服务器来说，要想处理这个请求，就必须监听指定的端口8080，当有TCP的请求包来时，建立Socket连接，分析并解析之，然后给客户端返回响应。在这个过程中，我们发现，其实包含了俩个功能点，即监听并接受请求和处理请求。那么我们能否将这俩个功能给抽象出来呢？Tomcat告诉我们，可以。是的，Tomcat将“监听并接收请求”抽象为org.apache.catalina.connector.Connector类，负责接受请求；将“处理请求”抽象为“容器”org.apache.catalina.Container，负责处理Connector传递过来的请求。

Ok,到此，我们分析构建的简单服务器模型出来了，Server由Connector组件和Container组件结合提供web服务。

图2

有了这个模型后，要实现一个简单的Server已经很简单了，但是在实现Container时，我们还是要做很多事情，如当来请求，我们怎么知道该请求对应得虚拟主机，以及请求的那个应用，应该交给那个servlet对象来处理？这样看来，Container还是太大了，需要细化。根据Servlet规范，我们知道，servlet属于某个应用，且有上下文环境，Container要根据应用上下文环境初始化servlet，然后根据servlet映射调用servlet的service方法。在这里“应用上下文环境”的概念很重要，Tomcat将其抽象为org.apache.catalina.Context，Context继承了Container接口。对于虚拟主机，Tomcat将其抽象为org.apache.catalina.Host，Host继承了Container接口。

好了，有了这些概念，我们再回顾一下请求的处理过程：浏览器发出请求，Connector接受请求，将请求交由Container处理，Container查找请求对应的Host并将请求传递给它，Host拿到请求后查找相应的应用上下文环境，准备servlet环境并调用service方法。

现在，我们的服务器模型变成了如图3所示了。

图3

但是在Tomcat的实现体系中还有一个Engine的接口，Engine也继承了Container接口，那么这个接口什么用呢？设计Engine的目的有俩个目的，一，当希望使用拦截器查看（过滤或预处理）每个请求时，Engine是个很好的拦截点。二，当希望多个虚拟Host共享一个Http的Connector时，Engine是个很好的门面。所以，Engine接口是作为顶级Container组件来设计的，其作用相当于一个Container的门面。有了Engine，请求的处理过程变为：浏览器发出请求，Connector接受请求，将请求交由Container（这里是Engine）处理，Container（Engine来担当）查找请求对应的Host并将请求传递给它，Host拿到请求后查找相应的应用上下文环境，准备servlet环境并调用service方法。再看看服务器的模型，如图4.

图4

到目前，我们碰到的组件类型有Connector和Container，其实，这也就是Tomcat的核心组件。如图4，一组Connector和一个Container有机的组合在一起构成Server，就可以提供服务了，对于Tomcat来说，主要是提供Servlet服务，那么也就是说Tomcat服务器也可以提供其它服务了？是的，Tomcat将“一组Connector和一个Container有机的组合”抽象为“服务”接口org.apache.catalina.Service，然而，这些服务实例彼此独立，仅仅共享JVM的基础设施，如系统类路径。

进一步的，我们得到了服务器的框架模型，如图5.

图5

由图5，我们知道，对于Tomcat服务器来说，除了Server代表它自己以外，其它组件都是功能组件，都有其职责范围。Service为最顶层的组件，可以添加Connector和Container组件。Engine是Container的最顶层组件，可以添加Host组件，但不能添加父组件。Host组件的父组件是Engine，Host下面包含有Context组件。

接下来看看标准的Tomcat体系结构，如图6.

图6

比较图5和图6.我们发现，还有很多辅助组件没有抽象出来。当然，随着需求的一步步加深，我的分析也会一步步深入，这些个组件也会慢慢浮出水面。

以上转自：

-------------------------------------------------------------------------------------------------------------------------------------

Tomcat从5.5版本开始，支持以下四种Connector的配置分别为 NIO, HTTP, POOL, NIOP：

NetworkClient

-->Socket-->PlainSocketImpl的native void socketConnect(InetAddress paramInetAddress, int paramInt1, int paramInt2)

NetworkServer

带main方法的ServerSocket

HttpURLConnection

-->HttpClient extends NetworkClient

tomcat 如何通过jmx loader 、digester架构

一、目录结构：

apache-tomcat-5.5.23\server\lib

apache-tomcat-5.5.23\common\lib

conf\context.xml

conf\web.xml

这个里面的加载

jasper-compiler.jar负责把index_jsp转化成index_jsp.servlet,（当首次访问该jsp时）

apache-tomcat-5.5.23\work\Catalina\localhost\myservlet\org\apache\jsp\index_jsp

二、

conf\server.xml元素结构

//1、端口。将port=80，进入本地服务时就不用敲80在末尾了（浏览器默认），这样当安装了IIS服务（80端口）时，tomcat无法启动（它是serversocket）。

</Host>

</Engine>

</Service>

</Server>

2.虚拟目录：所有的开发程序【JSP、servlet文件】保存在虚拟目录中。

设虚拟目录 "myweb"，通过 http://localhost:8080/myweb 访问物理路径 L:\java\JWeb 文件夹里面的内容。设置过程如下：

1.复制 Tomcat6.0\webapps\ROOT 目录下的 WEB-INF 文件夹到 L:\java\JWeb 目录下。

2.打开L:\java\JWeb\WEB-INF 目录下的 web.xml 文件,在 </description> 之后加入：

3.打开 Tomcat6.0\conf\server.xml 文件，在 <Host> 和 </Host> 之间加入：

path="/myweb" 就是虚拟目录的名称

docBase="L:\java\JWeb"> 为物理路径

4.打开 Tomcat6.0\conf\web.xml 文件，找到:

<init-param>

<param-name>listings</param-name>

<param-value>false</param-value>

</init-param>

把false设成true保存，重启Tomcat，现在就可以应用 http://localhost:8080/myweb 虚拟目录了。

1.1 - Server

A Server element represents the entire Catalina servlet container. (Singleton)

1.2 - Service

A Service element represents the combination of one or more Connector components that share a single Engine

Service是这样一个集合：它由一个或者多个Connector组成，以及一个Engine，负责处理所有Connector所获得的客户请求

1.3 - Connector

一个Connector将在某个指定端口上侦听客户请求，并将获得的请求交给Engine来处理，从Engine处获得回应并返回客户。

Coyote Http/1.1 Connector 在端口8080处侦听来自客户browser的http请求

Coyote JK2 Connector 在端口8009处侦听来自其它WebServer(Apache)的servlet/jsp代理请求

1.4 - Engine

An Engine is a Container that represents the entire Catalina servlet engine.

If used, an Engine is always the top level Container in a Catalina.

Engine下可以配置多个虚拟主机Virtual Host，每个虚拟主机都有一个域名。

当Engine获得一个请求时，它把该请求匹配到某个Host上，然后把该请求交给该Host来处理

1.5 - Host

架构：

Server: 其实就是BackGroud程序，在Tomcat里面的Server的用处是启动和监听服务端事件（诸如重启、关闭等命令。SHUTDOWN）

Service：一类问题的解决方案。默认使用Tomcat-Standalone 模式的service。既给我们提供解析jsp和servlet的服务，同时也提供给我们解析静态文本的服务。

Connector:从socket传递过来的数据，封装成Request, 传递给容器来处理。http、https、ajp（apache与tomcat）三种

Container: 当http connector把需求传递给顶级的container: Engin的时候，我们的视线就应该移动到Container这个层面来了。

在Container这个层，我们包含了3种容器： Engin, Host, Context.

Engin: 收到service传递过来的需求，处理后，将结果返回给service( service 是通过 connector 这个媒介来和Engin互动的 ).

Host: Engin收到service传递过来的需求后，不会自己处理，而是交给合适的Host来处理。

Host在这里就是虚拟主机的意思，通常我们都只会使用一个主机，既“localhost”本地机来处理。

Context: 一个web app，Host接到了从Host传过来的需求后，也不会自己处理，而是交给合适的Context来处理。

Compenent: 容器有各种各样的组件，提供各种各样的增值服务。

manager: 当一个容器里面装了manager组件后，这个容器就支持session管理了，事实上在tomcat里面的session管理，就是靠的在context里面装的manager component.

logger: 当一个容器里面装了logger组件后

loader: 通常只会给我们的context容器使用， loader是用来启动context以及管理这个context的classloader用的。

pipline: 容器间传递并过滤。

2. Tomcat的启动流程: 第一步是装配工作(父容器装上子容器,容器安插进组件)。第二步是启动工作。

2.3 Catalina.java

1. 使用Digester技术装配tomcat各个容器与组件。

1.1 装配工作的主要内容是安装各个大件。比如server下有什么样的servcie。 Host会容纳多少个context。 Context都会使用到哪些组件等等。

1.2 同时呢，在装配工作这一步，还完成了mbeans的配置工作。在这里，我简单地但不十分精确地描述一下mbean是什么，干什么用的。

我们自己生成的对象，自己管理，天经地义！但是如果我们创建了对象了，想让别人来管，怎么办呢？我想至少得告诉别人我们都有什么，以及通过什么方法可以找到吧！ JMX技术给我们提供了一种手段。 JMX里面主要有3种东西。Mbean, agent, connector.

Mbean：用来映射我们的对象。也许mbean就是我们创建的对象，也许不是，但有了它，就可以引用到我们的对象了。

Agent: 通过它，就可以找到mbean了。

Connector: 连接Agent的方式。可以是http的，也可以是rmi的，还可以直接通过socket。

发生在tomcat 装配过程中的事情: GlobalResourcesLifecycleListener 类的初始化会被触发：

protected static Registry registry = MBeanUtils.createRegistry(); 会运行

MBeanUtils.createRegistry() 会依据/org/apache/catalina/mbeans/mbeans-descriptors.xml这个配置文件创建 mbeans. Ok, 外界就有了条途径访问tomcat中的各个组件了。

2. 为top level 的server 做初始化工作。实际上就是做通常会配置给service的两条connector.(http, ajp)

3. 从server这个容器开始启动，点燃整个tomcat.

4. 为server做一个hook程序，检测当server shutdown的时候，关闭tomcat的各个容器用。

5. 监听8005端口，如果发送"SHUTDOWN"（默认培植下字符串）过来，关闭8005serverSocket。

2.4 启动各个容器

1. Server

触发Server容器启动前(before_start)，启动中(start)，启动后(after_start)3个事件，并运行相应的事件处理器。

启动Server的子容器：Servcie.

2. Service

启动Service的子容器：Engin

启动Connector

3. Engin

到了Engin这个层次，以及以下级别的容器， Tomcat就使用了比较一致的启动方式了。

首先，运行各个容器自己特有一些任务

随后，触发启动前事件

立即，设置标签，就表示该容器已经启动

接着，启动容器中的各个组件： loader, logger, manager等等

再接着，启动mapping组件。（注1）

紧跟着，启动子容器。

接下来，启动该容器的管道(pipline)

然后，触发启动中事件

最后，触发启动后事件。

Engin大致会这么做， Host大致也会这么做， Context大致还是会这么做。那么很显然地，我们需要在这里使用到代码复用的技术。 tomcat在处理这个问题的时候，漂亮地使用了抽象类来处理。 ContainerBase. 最后使得这部分完成复杂功能的代码显得干净利落，干练爽快，实在是令人觉得叹为观止，细细品来，直觉如享佳珍，另人齿颊留香，留恋往返啊！

Engin的触发启动前事件里，会激活绑定在Engin上的唯一一个Listener：EnginConfig。

这个EnginConfig类基本上没有做什么事情，就是把EnginConfig的调试级别设置为和Engin相当。另外就是输出几行文本，表示Engin已经配置完毕，并没有做什么实质性的工作。

注1: mapping组件的用处是，当一个需求将要从父容器传递到子容器的时候，而父容器又有多个子容器的话，那么应该选择哪个子容器来处理需求呢？这个由mapping 组件来定夺。

4. Host

同Engin一样，也是调用ContainerBase里面的start()方法，不过之前做了些自个儿的任务,就是往Host这个容器的通道（pipline）里面，安装了一个叫做

“org.apache.catalina.valves.ErrorReportValve”的阀门。

这个阀门的用处是这样的：需求在被Engin传递给Host后，会继续传递给Context做具体的处理。这里需求其实就是作为参数传递的Request, Response。所以在context把需求处理完后，通常会改动response。而这个org.apache.catalina.valves.ErrorReportValve的作用就是检察response是否包含错误，如果有就做相应的处理。

5. Context

到了这里，就终于轮到了tomcat启动中真正的重头戏，启动Context了。

StandardContext.start() 这个启动Context容器的方法被StandardHost调用.

5.1 webappResources 该context所指向的具体目录

5.2 安装defaultContex, DefaultContext 就是默认Context。如果我们在一个Host下面安装了DefaultContext，而且defaultContext里面又安装了一个数据库连接池资源的话。那么其他所有的在该Host下的Context, 都可以直接使用这个数据库连接池，而不用格外做配置了。

5.3 指定Loader. 通常用默认的org.apache.catalina.loader.WebappLoader这个类。 Loader就是用来指定这个context会用到哪些类啊，哪些jar包啊这些什么的。

5.4 指定 Manager. 通常使用默认的org.apache.catalina.session. StandardManager 。 Manager是用来管理session的。

其实session的管理也很好实现。以一种简单的session管理为例。当需求传递过来的时候，在Request对象里面有一个sessionId 属性。 OK，得到这个sessionId后，我们就可以把它作为map的key，而value我们可以放置一个HashMap. HashMap里边儿，再放我们想放的东西。

5.5 postWorkDirectory (). Tomcat下面有一个work目录。我们把临时文件都扔在那儿去。这个步骤就是在那里创建一个目录。一般说来会在%CATALINA_HOME%/work/Standalone\localhost\ 这个地方生成一个目录。

5.6 Binding thread。到了这里，就应该发生 class Loader 互换了。之前是看得见tomcat下面所有的class和lib. 接下来需要看得见当前context下的class。所以要设置contextClassLoader, 同时还要把旧的ClassLoader记录下来，因为以后还要用的。

5.7 启动 Loader. 指定这个Context具体要使用哪些classes，用到哪些jar文件。如果reloadable设置成了true, 就会启动一个线程来监视classes的变化，如果有变化就重新启动Context。

5.8 启动logger

5.9 触发安装在它身上的一个监听器。

lifecycle.fireLifecycleEvent(START_EVENT, null);

作为监听器之一，ContextConfig会被启动. ContextConfig就是用来配置web.xml的。比如这个Context有多少Servlet，又有多少Filter，就是在这里给Context装上去的。

5.9.1 defaultConfig. 每个context都得配置 tomcat/conf/web.xml 这个文件。

5.9.2 applicationConfig 配置自己的 WEB-INF/web.xml 文件

5.9.3 validateSecurityRoles 权限验证。通常我们在访问/admin 或者/manager的时候，需要用户要么是admin的要么是manager的，才能访问。而且我们还可以限制那些资源可以访问，而哪些不能。都是在这里实现的。

5.9.4 tldScan: 扫描一下，需要用到哪些标签(tag lab)

5.10 启动 manager

5.11 postWelcomeFiles() 我们通常会用到的3个启动文件的名称：

index.html、index.htm、index.jsp 就被默认地绑在了这个context上

5.12 listenerStart 配置listener

5.13 filterStart 配置 filter

5.14 启动带有<load-on-startup>1</load-on-startup>的Servlet.

顺序是从小到大： 1,2,3… 最后是0

默认情况下，至少会启动如下3个的Servlet:

org.apache.catalina.servlets.DefaultServlet

处理静态资源的Servlet. 什么图片啊， html啊， css啊， js啊都找他

org.apache.catalina.servlets.InvokerServlet

处理没有做Servlet Mapping的那些Servlet.

org.apache.jasper.servlet.JspServlet

处理JSP文件的.

5.15 标识context已经启动完毕,tomcat启动完毕。

/**

* A Host is a Container that represents a virtual host in the

* Catalina servlet engine. It is useful in the following types of scenarios:

* <ul>

* <li>You wish to use Interceptors that see every single request processed

* by this particular virtual host.

* <li>You wish to run Catalina in with a standalone HTTP connector, but still

* want support for multiple virtual hosts.

* </ul>

* In general, you would not use a Host when deploying Catalina connected

* to a web server (such as Apache), because the Connector will have

* utilized the web server's facilities to determine which Context (or

* perhaps even which Wrapper) should be utilized to process this request.

*

* The parent Container attached to a Host is generally an Engine, but may

* be some other implementation, or may be omitted if it is not necessary.

*

* The child containers attached to a Host are generally implementations

* of Context (representing an individual servlet context).

每个虚拟主机下都可以部署(deploy)一个或者多个Web App，每个Web App对应于一个Context，有一个Context path。

当Host获得一个请求时，将把该请求匹配到某个Context上，然后把该请求交给该Context来处理。

1.6 - Context

一个Context对应于一个Web Application，一个Web Application由一个或者多个Servlet组成。

Context在创建的时候将根据配置文件$CATALINA_HOME/conf/web.xml和$WEBAPP_HOME/WEB-INF/web.xml载入Servlet类。

当Context获得请求时，将在自己的映射表(mapping table)中寻找相匹配的Servlet类，如果找到，则执行该类，获得请求的回应，并返回。

1.7 - 示例

browser发送请求到本机端口8080--> Connector --> Engine --> Host --> Context --> servlet 构造request、response --> Context --> Host --> Engine -- > connector --> browser

public final class Bootstrap{

private static Bootstrap daemon = null;

private Object catalinaDaemon;

protected ClassLoader commonLoader;

protected ClassLoader catalinaLoader;

protected ClassLoader sharedLoader;//Webapp1Loader Webapp2Loader ...

public Bootstrap(){...}

private void initClassLoaders(){...}

catalinaDaemon = this.catalinaLoader.loadClass("org.apache.catalina.startup.Catalina").newInstance();

public void start()throws Exception{

Method method = this.catalinaDaemon.getClass().getMethod("start", (Class[])null);

method.invoke(this.catalinaDaemon, (Object[])null);

}

public class StandardService implements Lifecycle, Service, MBeanRegistration

protected Connector connectors[] = new Connector[0];

protected ArrayList<Executor> executors = new ArrayList<Executor>();

/**

* this holds the most recently added Engine.is generally an instance of Engine

protected Container container = null;

/**

* The lifecycle event support for this component.

private LifecycleSupport lifecycle = new LifecycleSupport(this);

/**

* The <code>Server</code> that owns this Service, if any.

private Server server = null;

/**

* The property change support for this component.

protected PropertyChangeSupport support = new PropertyChangeSupport(this);

public void addConnector(Connector connector) {}

public void addPropertyChangeListener(PropertyChangeListener listener) {}

public void addExecutor(Executor ex) {}

public void addLifecycleListener(LifecycleListener listener) {}

}

//embed [im'bed] 嵌入

public class Embedded extends StandardServic{

public synchronized void addEngine(Engine engine) {}

}

//启动Tomcat，就生成Catalina实例,server实例？？？？

根据配置文件server.xml，实例化的对象。对象实例化过程中，会做载入webapp，在特定端口等待客户连接等工作。

从server.xml到对象的映射是通过commons-digester.jar包完成的。这个包的一个主要功能就是映射xml到java对象。

public class Catalina extends Embedded {

protected String configFile = "conf/server.xml";

/**

* The application main program.

* @param args Command line arguments

public static void main(String args[]) {

(new Catalina()).process(args);

}

/**

* The instance main program.

* @param args Command line arguments

public void process(String args[]) {

load(args);

start();

}

/**

* Start a new server instance.

public void start() {

((Lifecycle) getServer()).start();

}

protected Digester createStartDigester() {

digester.addObjectCreate("Server",

"org.apache.catalina.core.StandardServer",

"className");

digester.addSetProperties("Server");

digester.addSetNext("Server",

"setServer",

"org.apache.catalina.Server");

digester.addSetNext("Server/GlobalNamingResources",

"setGlobalNamingResources",

"org.apache.catalina.deploy.NamingResources");

digester.addSetNext("Server/Listener",

"addLifecycleListener",

"org.apache.catalina.LifecycleListener");

digester.addSetNext("Server/Service",

"addService",

"org.apache.catalina.Service");

digester.addSetNext("Server/Service/Listener",

"addLifecycleListener",

"org.apache.catalina.LifecycleListener");

digester.addSetNext("Server/Service/Executor",

"addExecutor",

"org.apache.catalina.Executor");

digester.addSetNext("Server/Service/Connector",

"addConnector",

"org.apache.catalina.connector.Connector");

digester.addSetNext("Server/Service/Connector/Listener",

"addLifecycleListener",

"org.apache.catalina.LifecycleListener");

}

//available for use(but not required) when deploying and starting Catalina.

public final class StandardServer implements Lifecycle, Server, MBeanRegistration{

public StandardServer() {

ServerFactory.setServer(this);

globalNamingResources = new NamingResources();

globalNamingResources.setContainer(this);

if (isUseNaming()) {

if (namingContextListener == null) {

namingContextListener = new NamingContextListener();

addLifecycleListener(namingContextListener);

}

private javax.naming.Context globalNamingContext = null;

private NamingResources globalNamingResources = null;

private NamingContextListener namingContextListener = null;

/**

* The port number on which we wait for shutdown commands.

private int port = 8005;

awaitSocket = new ServerSocket(port, 1, InetAddress.getByName("localhost"));

}

public class Connector implements Lifecycle, MBeanRegistration{

protected Service service = null;

/**

* The Container used for processing requests received by this Connector.

protected Container container = null;

/**

* Use "/" as path for session cookies ?

protected boolean emptySessionPath = false;

/**

* The redirect port for non-SSL to SSL redirects.

protected int redirectPort = 443;

/**

* The request scheme that will be set on all requests received through this connector.

protected String scheme = "http";

/**

* Maximum size of a POST which will be automatically parsed by the

* container. 2MB by default.

protected int maxPostSize = 2 * 1024 * 1024;

/**

* Maximum size of a POST which will be saved by the container

* during authentication可信的. 4kB by default

protected int maxSavePostSize = 4 * 1024;

/**

* The background thread.

protected Thread thread = null;

/**

* Coyote Protocol handler class name.

* Defaults to the Coyote HTTP/1.1 protocolHandler.

protected String protocolHandlerClassName =

"org.apache.coyote.http11.Http11Protocol";

/**

* Coyote protocol handler.

protected ProtocolHandler protocolHandler = null;

/**

* Coyote adapter.

protected Adapter adapter = null;

/**

* Mapper.

protected Mapper mapper = new Mapper();

/**

* Mapper listener.

protected MapperListener mapperListener = new MapperListener(mapper, this);

/**

* URI encoding.

protected String URIEncoding = null;

/**

* URI encoding as body.

protected boolean useBodyEncodingForURI = false;

/**

* Set the Coyote protocol which will be used by the connector.

public void setProtocol(String protocol) {

if (AprLifecycleListener.isAprAvailable()) {

if ("HTTP/1.1".equals(protocol)) {

setProtocolHandlerClassName

("org.apache.coyote.http11.Http11AprProtocol");

} else if ("AJP/1.3".equals(protocol)) {

setProtocolHandlerClassName

("org.apache.coyote.ajp.AjpAprProtocol");

} else if (protocol != null) {

setProtocolHandlerClassName(protocol);

} else {

setProtocolHandlerClassName

("org.apache.coyote.http11.Http11AprProtocol");

}

} else {

if ("HTTP/1.1".equals(protocol)) {

setProtocolHandlerClassName

("org.apache.coyote.http11.Http11Protocol");

} else if ("AJP/1.3".equals(protocol)) {

setProtocolHandlerClassName

("org.apache.jk.server.JkCoyoteHandler");

} else if (protocol != null) {

setProtocolHandlerClassName(protocol);

}

/**

* Create (or allocate) and return a Request object suitable for

* specifying the contents of a Request to the responsible Container.

org.apache.catalina.connector.Request

public Request createRequest() {

Request request = new Request();

request.setConnector(this);

return (request);

}

/**

* Create (or allocate) and return a Response object suitable for

* receiving the contents of a Response from the responsible Container.

public Response createResponse() {

Response response = new Response();

response.setConnector(this);

return (response);

}

// 省略------------------------------------------------------ Lifecycle Methods

// 省略-------------------- JMX registration --------------------

/**

* Shutdown hook which will perform a clean shutdown of Catalina if needed.

protected class CatalinaShutdownHook extends Thread {

public void run() {

try {

if (getServer() != null) {

Catalina.this.stop();

}

} catch (Throwable ex) {

log.error(sm.getString("catalina.shutdownHookFail"), ex);

} finally {

// If JULI is used, shut JULI down *after* the server shuts down

// so log messages aren't lost

LogManager logManager = LogManager.getLogManager();

if (logManager instanceof ClassLoaderLogManager) {

((ClassLoaderLogManager) logManager).shutdown();

}

public interface Engine extends Container {

public String getDefaultHost();

public void setDefaultHost(String defaultHost);

public String getJvmRoute();

public void setJvmRoute(String jvmRouteId);

public Service getService();

public void setService(Service service);

}

public class StandardEngine extends ContainerBase implements Engine{}

public class StandardHost extends ContainerBase implements Host{

/**

* The set of aliases for this Host.

private String[] aliases = new String[0];

private final Object aliasesLock = new Object();

/**

* The application root for this Host.

private String appBase = "webapps";

/**

* The auto deploy flag for this Host.

private boolean autoDeploy = true;

/**

* The Java class name of the default context configuration class

* for deployed web applications.

private String configClass =

"org.apache.catalina.startup.ContextConfig";

/**

* The Java class name of the default Context implementation class for

* deployed web applications.

private String contextClass =

"org.apache.catalina.core.StandardContext";

/**

* Attribute value used to turn on/off XML namespace awarenes.

private boolean xmlNamespaceAware = false;

/**

* Track the class loaders for the child web applications so memory leaks漏洞

* can be detected.

private Map<ClassLoader, String> childClassLoaders =

new WeakHashMap<ClassLoader, String>();

...其他的field省略

}

/**

* Standard implementation of the Context interface. Each

* child container must be a Wrapper implementation to process the

* requests directed to a particular servlet.

public class StandardContext extends ContainerBase implements Context, Serializable, NotificationEmitter{

/**

* The ServletContext implementation associated with this Context.

protected transient ApplicationContext context = null;

/**

* Compiler classpath to use.

private String compilerClasspath = null;

/**

* Should we attempt to use cookies for session id communication?

private boolean cookies = true;

/**

* Should we allow the <code>ServletContext.getContext()</code> method

* to access the context of other web applications in this server?

private boolean crossContext = false;

/**

* The MIME mappings for this web application, keyed by extension.

private HashMap mimeMappings = new HashMap();

/**

* The servlet mappings for this web application, keyed by

* matching pattern.

private HashMap servletMappings = new HashMap();

/**

* The welcome files for this application.

private String welcomeFiles[] = new String[0];

/**

* Cache object max size in KB.

protected int cacheObjectMaxSize = 512; // 512K

/**

* Cache TTL in ms.

protected int cacheTTL = 5000;

/**

* The domain to use for session cookies. <code>null</code> indicates that

* the domain is controlled by the application.

private String sessionCookieDomain;

/**

* The path to use for session cookies. <code>null</code> indicates that

* the path is controlled by the application.

private String sessionCookiePath;

/**

* The name to use for session cookies. <code>null</code> indicates that

* the name is controlled by the application.

private String sessionCookieName;

}

/**

* Standard implementation of the Wrapper interface that represents

* an individual servlet definition. No child Containers are allowed, and

* the parent Container must be a Context.

public interface Wrapper extends Container{}

public class StandardWrapper extends ContainerBase implemen ts ServletConfig, Wrapper, NotificationEmitter {

/**

* The (single) initialized instance of this servlet.

protected Servlet instance = null;

/**

* The context-relative URI of the JSP file for this servlet.

protected String jspFile = null;

}

/**

* Standard implementation of <code>ServletContext</code> that represents

* a web application's execution environment. An instance of this class is

* associated with each instance of <code>StandardContext</code>.

public class ApplicationContext implements ServletContext {

/**

* The Context instance with which we are associated.

private StandardContext context = null;

/**

* Base path.

private String basePath = null;

public String getRealPath(String path) {

File file = new File(basePath, path);

return (file.getAbsolutePath());

}

/**

* Return a <code>RequestDispatcher</code> instance that acts as a

* wrapper for the resource at the given path. The path must begin

* with a "/" and is interpreted as relative to the current context root.

* @param path The path to the desired resource.

public RequestDispatcher getRequestDispatcher(String path) {}

protected StandardContext getContext() {

return this.context;

}

/**

* Startup event listener for a Context that configures the properties

* of that Context, and the associated defined servlets.

public class ContextConfig implements LifecycleListener {

/**

* The Context we are associated with.

protected Context context = null;

/**

* The default web application's context file location.

protected String defaultContextXml = null;

/**

* The default web application's deployment descriptor location.

protected String defaultWebXml = null;

}

org.apache.catalina.core.ApplicationHttpRequest

extends javax.servlet.http.HttpServletRequestWrapper

extends javax.servlet.ServletRequestWrapper

//作用类似javaBean

public final class org.apache.coyote.Request{

private int serverPort = -1;

private UDecoder urlDecoder = new UDecoder();

private MimeHeaders headers = new MimeHeaders();

private MessageBytes uriMB = MessageBytes.newInstance();

}

org.apache.catalina.connector.Request implements HttpServletRequest{

protected org.apache.coyote.Request coyoteRequest

public InputStream getStream() {

if (inputStream == null) {

inputStream = new CoyoteInputStream(inputBuffer);

}

return inputStream;

}

protected int readPostBody(byte body[], int len)throws IOException {

int inputLen = getStream().read(body, offset, len - offset);

}

/**

* Return the session associated with this Request, creating one

* if necessary and requested.

public HttpSession getSession(boolean create) {

Session session = doGetSession(create);

if (session != null) {

return session.getSession();

} else {

return null;

}

/**

* Change the ID of the session that this request is associated with. There

* are several things that may trigger an ID change. These include moving

* between nodes in a cluster and session fixation prevention during the

* authentication process.

public void changeSessionId(String newSessionId) {...}

protected Session doGetSession(boolean create) {

// Attempt to reuse session id if one was submitted in a cookie

// Do not reuse the session id if it is from a URL, to prevent possible

// phishing attacks

if (connector.getEmptySessionPath()

&& isRequestedSessionIdFromCookie()) {

session = manager.createSession(getRequestedSessionId());

} else {

//createSession最终会调用StandardSession的构造。

session = manager.createSession(null);

}

// Creating a new session cookie based on that session

if ((session != null) && (getContext() != null)

&& getContext().getCookies()) {

String scName = context.getSessionCookieName();

if (scName == null) {

scName = Globals.SESSION_COOKIE_NAME;

}

Cookie cookie = new Cookie(scName, session.getIdInternal());

configureSessionCookie(cookie);

//save到浏览器内存

response.addSessionCookieInternal(cookie, context.getUseHttpOnly());

}

/**

* Parse accept-language header value.

protected void parseLocalesHeader(String value) {...}

public String getParameter(String name) {...}

}

Connector通过8080端口连接coyote http1.1,通过8009连接coyote AJP1.3

ServerCookie、Cookies与javax.servlet.http.Cookie的联系？

cookie如何实现的？还有浏览器的。如何获取解析cookie、url重写过的sessionid

/**

* Server-side cookie representation.

* Allows recycling and uses MessageBytes as low-level

* representation ( and thus the byte-> char conversion can be delayed

* until we know the charset ).

* Tomcat.core uses this recyclable object to represent cookies,

* and the facade will convert it to the external representation.

public class org.apache.tomcat.util.http.ServerCookie implements Serializable {...}

/**

* A collection of cookies - reusable and tuned for server side performance.

* Based on RFC2965 ( and 2109 )

public final class org.apache.tomcat.util.http.Cookies {

ServerCookie scookies[]=new ServerCookie[INITIAL_SIZE];

/** Register a new, unitialized cookie. Cookies are recycled, and

* most of the time an existing ServerCookie object is returned.

* The caller can set the name/value and attributes for the cookie

public ServerCookie addCookie() {

if( cookieCount >= scookies.length ) {

ServerCookie scookiesTmp[]=new ServerCookie[2*cookieCount];

System.arraycopy( scookies, 0, scookiesTmp, 0, cookieCount);

scookies=scookiesTmp;

}

ServerCookie c = scookies[cookieCount];

if( c==null ) {

c= new ServerCookie();

scookies[cookieCount]=c;

}

cookieCount++;

return c;

}

/** Add all Cookie found in the headers of a request.

public void processCookies( MimeHeaders headers ) {...

/**

* Parses a cookie header after the initial "Cookie:"

* [WS][$]token[WS]=[WS](token|QV)[;|,]

* RFC 2965

* JVK

public final void processCookieHeader(byte bytes[], int off, int len){...}

}

//为什么要多这个对象StandardSessionFacade？？？？？

public class StandardSessionFacade implements HttpSession {

private HttpSession session = null;

}

/**

* Standard implementation of the Session interface. This object is

* serializable, so that it can be stored in persistent storage or transferred

* to a different JVM for distributable session support.

* If you add fields to this class, you must

* make sure that you carry them over in the read/writeObject methods so

* that this class is properly serialized.

public class StandardSession implements HttpSession, Session, Serializable {

/**

* The time this session was created, in milliseconds since midnight,

* January 1, 1970 GMT.

protected long creationTime = 0L;

/**

* Return the <code>HttpSession</code> for which this object

* is the facade.

protected static HttpSessionContext sessionContext = null;

protected transient StandardSessionFacade facade = null;

public HttpSession getSession() {

return (facade);

}

/**

* The HTTP session context associated with this session.

/**

* Inform通知 the listeners about the new session.此类中有多种多个event、listener

public void tellNew() {...}

/**

* Update the accessed time information for this session. This method

* should be called by the context when a request comes in for a particular

* session, even if the application does not reference it.

* 会被invokeHttp11NioProcessor之类的invoke(request, response)调用;

public void access() {...}

}

/**

* Standard implementation of the Server interface, available for use

* (but not required) when deploying and starting Catalina.

* @author Craig R. McClanahan

* @version $Id: StandardServer.java 1066492 2011-02-02 15:02:49Z kkolinko $

public final class StandardServer implements Lifecycle, Server, MBeanRegistration {

awaitSocket = new ServerSocket(port, 1,InetAddress.getByName("localhost"));

}

好多类中都会创建ServerSocket比如下面这几个：

org\apache\coyote\http11\Http11Protocol.java

org\apache\jk\common\ChannelNioSocket.java

ServerSocketChannel ssc = ServerSocketChannel.open();

org\apache\jk\common\ChannelSocket.java

ServerSocket sSocket = new ServerSocket( i, backlog );

org\apache\tomcat\util\net\JIoEndpoint.java

serverSocket = serverSocketFactory.createSocket(port, backlog);

org\apache\tomcat\util\net\NioEndpoint.java

serverSock = ServerSocketChannel.open();

其实创建一个 session 并不耗什么资源，无非就是一个空的map，就是别往里面塞太多的东西，尤其是在集群环境下，会增加同步的负担。

在文件《D:\study\src_zip\org\apache\catalina\core\StandardServer.java》中查找："getInputStream"

stream = socket.getInputStream();

以上转自：

(精)tomcat 源码学习

Ne0inhk

Read more

60个“特征工程”计算函数（Python代码）

90w，确实可以封神了！

再见nohup！试试这个神器，Python Supervisor！

第一本给程序员看的AI Agent图书上市了!