Tomcat 第四篇:请求处理流程(上)
Posted 极客挖掘机
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Tomcat 第四篇:请求处理流程(上)相关的知识,希望对你有一定的参考价值。
1. 引言
既然是在讲 Tomcat ,那么一个 HTTP 请求的请求流程是无论如何也绕不开的。
首先抛开所有,使用我们现有的知识面,猜测一下一个请求被 Tomcat 处理的过程:
1. 客户端(浏览器)发送一个请求(HTTP)
2. 建立 Socket 连接
3. 通过 Socket 读取数据
4. 根据协议(HTTP)解析请求
5. 调用对应的代码完成响应
上面这套流程,我相信任何一个 Java 码农都能想得到,当 Tomcat 接受到请求后,经过一系列的基础处理,最终会调用到我们自己的业务程序上,或者说是 Servlet 上,在早期,这些请求会由我们自己实现的 jsp 或者是 Servlet 进行接收,随着时代的发展以及演进,出现了 Struts 和 Spring 等中间件来帮助我们完成基础的请求处理,使得开发人员更加关注具体的业务。
我想很多人都很好奇, Tomcat 是如何将这些 HTTP 请求转交给我们的 Servlet 的?
2. Connector 初始化
上一篇我们在聊 Tomcat 启动流程的时候,最后执行初始化的是 org.apache.catalina.connector.Connector#initInternal()
,这时整个初始化流程到了 Connector
,看一下这段代码:
// 去除部分代码
protected void initInternal() throws LifecycleException {
super.initInternal();
// Initialize adapter
adapter = new CoyoteAdapter(this);
protocolHandler.setAdapter(adapter);
// ......
try {
protocolHandler.init();
} catch (Exception e) {
throw new LifecycleException(
sm.getString("coyoteConnector.protocolHandlerInitializationFailed"), e);
}
}
这段代码中主要做了两件事情:
-
构造了 CoyoteAdapter 对象,并且将其设置为 ProtocolHandler 的 Adapter 。 -
调用了 org.apache.coyote.ProtocolHandler#init()
的方法。
先说第二件事情,调用了 org.apache.coyote.ProtocolHandler#init()
,ProtocolHandler
是在构造方法中进行的初始化,这里的核心代码是:
setProtocol(protocol)
再看下 setProtocol()
这个方法做了啥:
public void setProtocol(String protocol) {
boolean aprConnector = AprLifecycleListener.isAprAvailable() &&
AprLifecycleListener.getUseAprConnector();
if ("HTTP/1.1".equals(protocol) || protocol == null) {
if (aprConnector) {
setProtocolHandlerClassName("org.apache.coyote.http11.Http11AprProtocol");
} else {
setProtocolHandlerClassName("org.apache.coyote.http11.Http11NioProtocol");
}
} else if ("AJP/1.3".equals(protocol)) {
if (aprConnector) {
setProtocolHandlerClassName("org.apache.coyote.ajp.AjpAprProtocol");
} else {
setProtocolHandlerClassName("org.apache.coyote.ajp.AjpNioProtocol");
}
} else {
setProtocolHandlerClassName(protocol);
}
}
看到这里可以知道,主逻辑分成了两块,一块是使用 HTTP/1.1
协议,另一块是使用了 AJP/1.3
的协议,这里通过协议的不同,最终初始化了不同的类。
如果是使用 HTTP/1.1
的协议,则采用了 org.apache.coyote.http11.Http11AprProtocol
或者 org.apache.coyote.http11.Http11NioProtocol
,如果是采用 AJP/1.3
则采用 org.apache.coyote.ajp.AjpAprProtocol
或者是 org.apache.coyote.ajp.AjpNioProtocol
。
看下 org.apache.coyote.http11.Http11AprProtocol
和 org.apache.coyote.ajp.AjpAprProtocol
继承关系图:
可以看到这两个类都继承自 org.apache.coyote.AbstractProtocol
,通过查看 org.apache.coyote.AbstractProtocol#init()
方法,可以看到是调用了 org.apache.tomcat.util.net.AbstractEndpoint#init()
,而 AbstractEndpoint
的实例化操作是在实例化 AjpProtocol
和 Http11Protocol
的时候在其构造函数中实例化的,而在 AjpProtocol
和 Http11Protocol
的构造函数中,实际上是都初始化了 org.apache.tomcat.util.net.JIoEndpoint
,只不过根据不同的 HTTP 或者是 AJP 协议,它们具有不同的连接处理类。其中 Http11Protocol
的连接处理类为 org.apache.coyote.http11.Http11Protocol.Http11ConnectionHandler
,而连接处理类为 org.apache.coyote.ajp.AjpProtocol.AjpConnectionHandler
。
除此之外, ProtocolHandler
还有其他实现,都在 org.apache.coyote
这个包中,一些常见的类图如下:
因此到这里我们基本清楚了 Connector
的初始化流程,总结如下:
//1 HTTP/1.1协议连接器
org.apache.catalina.connector.Connector#init
->org.apache.coyote.http11.Http11AprProtocol#init
-->org.apache.tomcat.util.net.AprEndpoint#init
(org.apache.coyote.http11.Http11AprProtocol.Http11ConnectionHandler)
// 2 AJP/1.3协议连接器
org.apache.catalina.connector.Connector#init
->org.apache.coyote.ajp.AjpAprProtocol#init
-->org.apache.tomcat.util.net.AprEndpoint#init
(org.apache.coyote.ajp.AjpAprProtocol.AjpConnectionHandler)
3. Connector 启动
ProtocolHandler 的初始化稍微有些特殊,Server、Service、Connector 这三个容器的初始化顺序为:Server -> Service -> Connector 。值得注意的是, ProtocolHandler 作为 Connector 的子容器,其初始化过程并不是由 Connector 的 initInternal 方法调用的,而是与启动过程一道被 Connector 的 startInternal 方法所调用。
@Override
protected void startInternal() throws LifecycleException {
// Validate settings before starting
if (getPort() < 0) {
throw new LifecycleException(sm.getString(
"coyoteConnector.invalidPort", Integer.valueOf(getPort())));
}
setState(LifecycleState.STARTING);
try {
protocolHandler.start();
} catch (Exception e) {
throw new LifecycleException(
sm.getString("coyoteConnector.protocolHandlerStartFailed"), e);
}
}
这里也总共做了两件事儿:
-
将 Connector 容器的状态更改为启动中(LifecycleState.STARTING) 。 -
启动 ProtocolHandler 。
简单起见,以 Http11Protocol 为例介绍 ProtocolHandler 的 start 方法:
由于 ProtocolHandler
是一个接口,它的 start
方法有两个抽象类进行实现:
-
org.apache.coyote.AbstractAjpProtocol -
org.apache.coyote.ajp.AbstractProtocol
这里我们仅讨论 org.apache.coyote.ajp.AbstractProtocol
,看下它的 start
的方法:
@Override
public void start() throws Exception {
if (getLog().isInfoEnabled()) {
getLog().info(sm.getString("abstractProtocolHandler.start", getName()));
}
endpoint.start();
// Start timeout thread
asyncTimeout = new AsyncTimeout();
Thread timeoutThread = new Thread(asyncTimeout, getNameInternal() + "-AsyncTimeout");
int priority = endpoint.getThreadPriority();
if (priority < Thread.MIN_PRIORITY || priority > Thread.MAX_PRIORITY) {
priority = Thread.NORM_PRIORITY;
}
timeoutThread.setPriority(priority);
timeoutThread.setDaemon(true);
timeoutThread.start();
}
这里最核心的一句代码是调用了 endpoint.start()
,这里的 endpoint
是抽象类 AbstractEndpoint#start()
:
public final void start() throws Exception {
if (bindState == BindState.UNBOUND) {
bind();
bindState = BindState.BOUND_ON_START;
}
startInternal();
}
这一段也做了两件事儿:
-
判断当前绑定状态,如果没有绑定,则会先去绑定,调用 bind()
。 -
然后调用 startInternal()
进行初始化。
AbstractEndpoint
有三个子类:
我们专注于 AprEndpoint
这个子类,上面 AbstractEndpoint
抽象类中的两个方法 bind()
和 startInternal()
都会在这个类中进行实现。
我们先看 bind()
方法:
/**
* Initialize the endpoint.
*/
@Override
public void bind() throws Exception {
// Create the root APR memory pool
try {
rootPool = Pool.create(0);
} catch (UnsatisfiedLinkError e) {
throw new Exception(sm.getString("endpoint.init.notavail"));
}
// Create the pool for the server socket
serverSockPool = Pool.create(rootPool);
// Create the APR address that will be bound
String addressStr = null;
if (getAddress() != null) {
addressStr = getAddress().getHostAddress();
}
int family = Socket.APR_INET;
if (Library.APR_HAVE_IPV6) {
if (addressStr == null) {
if (!OS.IS_BSD) {
family = Socket.APR_UNSPEC;
}
} else if (addressStr.indexOf(':') >= 0) {
family = Socket.APR_UNSPEC;
}
}
long inetAddress = Address.info(addressStr, family,
getPort(), 0, rootPool);
// Create the APR server socket
serverSock = Socket.create(Address.getInfo(inetAddress).family,
Socket.SOCK_STREAM,
Socket.APR_PROTO_TCP, rootPool);
if (OS.IS_UNIX) {
Socket.optSet(serverSock, Socket.APR_SO_REUSEADDR, 1);
}
if (Library.APR_HAVE_IPV6) {
if (getIpv6v6only()) {
Socket.optSet(serverSock, Socket.APR_IPV6_V6ONLY, 1);
} else {
Socket.optSet(serverSock, Socket.APR_IPV6_V6ONLY, 0);
}
}
// Deal with the firewalls that tend to drop the inactive sockets
Socket.optSet(serverSock, Socket.APR_SO_KEEPALIVE, 1);
// Bind the server socket
int ret = Socket.bind(serverSock, inetAddress);
if (ret != 0) {
throw new Exception(sm.getString("endpoint.init.bind", "" + ret, Error.strerror(ret)));
}
// Start listening on the server socket
ret = Socket.listen(serverSock, getAcceptCount());
if (ret != 0) {
throw new Exception(sm.getString("endpoint.init.listen", "" + ret, Error.strerror(ret)));
}
if (OS.IS_WIN32 || OS.IS_WIN64) {
// On Windows set the reuseaddr flag after the bind/listen
Socket.optSet(serverSock, Socket.APR_SO_REUSEADDR, 1);
}
// Enable Sendfile by default if it has not been configured but usage on
// systems which don't support it cause major problems
if (!useSendFileSet) {
setUseSendfileInternal(Library.APR_HAS_SENDFILE);
} else if (getUseSendfile() && !Library.APR_HAS_SENDFILE) {
setUseSendfileInternal(false);
}
// Initialize thread count default for acceptor
if (acceptorThreadCount == 0) {
// FIXME: Doesn't seem to work that well with multiple accept threads
acceptorThreadCount = 1;
}
// Delay accepting of new connections until data is available
// Only Linux kernels 2.4 + have that implemented
// on other platforms this call is noop and will return APR_ENOTIMPL.
if (deferAccept) {
if (Socket.optSet(serverSock, Socket.APR_TCP_DEFER_ACCEPT, 1) == Status.APR_ENOTIMPL) {
deferAccept = false;
}
}
// Initialize SSL if needed
if (isSSLEnabled()) {
for (SSLHostConfig sslHostConfig : sslHostConfigs.values()) {
createSSLContext(sslHostConfig);
}
SSLHostConfig defaultSSLHostConfig = sslHostConfigs.get(getDefaultSSLHostConfigName());
if (defaultSSLHostConfig == null) {
throw new IllegalArgumentException(sm.getString("endpoint.noSslHostConfig",
getDefaultSSLHostConfigName(), getName()));
}
Long defaultSSLContext = defaultSSLHostConfig.getOpenSslContext();
sslContext = defaultSSLContext.longValue();
SSLContext.registerDefault(defaultSSLContext, this);
// For now, sendfile is not supported with SSL
if (getUseSendfile()) {
setUseSendfileInternal(false);
if (useSendFileSet) {
log.warn(sm.getString("endpoint.apr.noSendfileWithSSL"));
}
}
}
}
这个方法上面的注释已经写的比较清楚了,首先第一个方法注释就告诉我们这个方法是用来初始化 endpoint
的,大体做了这么几件事儿:
-
创建了 APR 的 rootPool ,从命名上看这应该是一个根连接池。 -
创建一个 serverSockPool ,使用刚才创建的 rootPool 进行创建,这个命名大家就都看得懂了。 -
创建用来做绑定的 APR 的地址。 -
创建一个 APR server socket -> serverSock ,这里开启了 socket 。 -
将刚才创建的 server 和 socket 进行绑定。 -
开启 server socket 上面的监听。 -
一些系统层面的设置。 -
如果需要的话,还会进行一些 SSL 的相关设置。
接着看下 startInternal()
方法:
/**
* Start the APR endpoint, creating acceptor, poller and sendfile threads.
*/
@Override
public void startInternal() throws Exception {
if (!running) {
running = true;
paused = false;
processorCache = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,
socketProperties.getProcessorCache());
// Create worker collection
if (getExecutor() == null) {
createExecutor();
}
initializeConnectionLatch();
// Start poller thread
poller = new Poller();
poller.init();
Thread pollerThread = new Thread(poller, getName() + "-Poller");
pollerThread.setPriority(threadPriority);
pollerThread.setDaemon(true);
pollerThread.start();
// Start sendfile thread
if (getUseSendfile()) {
sendfile = new Sendfile();
sendfile.init();
Thread sendfileThread =
new Thread(sendfile, getName() + "-Sendfile");
sendfileThread.setPriority(threadPriority);
sendfileThread.setDaemon(true);
sendfileThread.start();
}
startAcceptorThreads();
}
}
这个方法所有的前提条件都在于如果 AprEndpoint
尚未出于运行中,即 running == true
,首先如果没有创建线程池 getExecutor() == null
,则需要调用 createExecutor()
方法创建线程池和任务队列 TaskQueue
。
public void createExecutor() {
internalExecutor = true;
TaskQueue taskqueue = new TaskQueue();
TaskThreadFactory tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS,taskqueue, tf);
taskqueue.setParent( (ThreadPoolExecutor) executor);
}
剩下两个是创建了两个线程,分别是 poller 和 sendfile ,这两个都是 AprEndpoint
的内部类,这两个线程一个是用来做轮询,另一个是用来做数据发送。
至此, Tomcat 中为请求处理的准备工作已经完成。
以上是关于Tomcat 第四篇:请求处理流程(上)的主要内容,如果未能解决你的问题,请参考以下文章
第四篇Camunda系列-ProcessEngine核心对象
第四篇Camunda系列-ProcessEngine核心对象
第四篇Camunda系列-ProcessEngine核心对象