tomcat原理解析：整体架构

Posted 2020-10-06 csguo

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了tomcat原理解析：整体架构相关的知识，希望对你有一定的参考价值。

一整体结构

前面tomcat实现原理(一)里面描述了整个tomcat接受一个http请求的简单处理，这里面我们讲下整个tomcat的架构，以便对整体结构有宏观的了解。tomat里面由很多个容器结合在一起，主要有server,service,context,host,engine,wrapper,connector这7个容器来组装。当然了tomcat里面还有其它容器这里就不一一列举，因为我只看重点的。这7个容器存着父子关系，即可以通过当前容器找自己的父容器和自己的子容器。说到这我画了一个简单的结构图，让这种关系更加直观。如下：

根据图可以看出server是最外层的一个容器，它里面可以包含了Service容器，Service容器里面又包含了Connector和Engine，Engine容器里面又包含了Host，Host容器包含Context，Context容器包含Wrapper容器。就好比一个人有最外层的躯体，躯体里面有心脏，肺，胃，肾脏等等很多个个功能器件。

二组件描述

这里主要通过tomcat的源码来分析这7个容器是通过什么样的机制来组织在一起的，相互的包含的关系怎么处理。

1.server组件

server就像一个架子，很多其它子容器都装配在这个架子上。同时这个容器又暴露了一些入口对外提供服务。比如初始化服务，启动服务，停止服务等。源码中的server是一个接口，如下图:

技术分享

查看Server接口类它还继承着Lifecycle接口，详情如下图：

Lifecycle接口控制着各个组件的生命周期，比如接口中的抽象方法init()初始化,start()启动,stop()停止,destory()销毁。 Server的标准实现类为StandardServer,细读StandardServer里面的接口addService,findServices的实现代码，可以看出这Service和 Server有着关联，Server可以有多个Service以数组的形式保存在其中。

[html] view plain copy

public void addService(Service service) {
service.setServer(this);
synchronized (services) {
Service results[] = new Service[services.length + 1];
System.arraycopy(services, 0, results, 0, services.length);
results[services.length] = service;
services = results;
if (getState().isAvailable()) {
try {
service.start();
} catch (LifecycleException e) {
// Ignore
}
}
// Report this property change to interested listeners
support.firePropertyChange("service", null, service);
}
}<span style="font-family:Microsoft YaHei;font-size:12px;">
</span>

1.将设置进来的Service 对象设置父组件为Server

2.重新构建了一个Service数组，然后将老的Service拷贝到新的数组中，同时追加新的Service组件

3.根据当前组件的生命状态，判断新加入的组件是否需要启动

2.Service组件

service接口它也继承Lifecycle接口。前面说过了service组件的父组件是server组件，结构如下图：

技术分享

它的标准实现是StandardService类，查看接口抽象方法addConnector的具体实现可以看出通过它可以给service容器添加connector容器，这里的connector就主要负责接收浏览器客户端发过来的http请求，仔细看里面的源码可以发现它接到请求时生成了一个socket对象，并将这个socket对象放入了一个线程中，同时线程会存入一个线程池来处理这次响应，并根据请求的详情信息来定位响应资源，响应的资源通过Engine容器给出。它就像浏览器和 Engine容器的桥梁，具体如何响应请求的会通过后面的章节来细说。先看是怎么将connector容器绑定到service中。如下面代码：

[html] view plain copy

public void addConnector(Connector connector) {
synchronized (connectors) {
connector.setService(this);
Connector results[] = new Connector[connectors.length + 1];
System.arraycopy(connectors, 0, results, 0, connectors.length);
results[connectors.length] = connector;
connectors = results;
if (getState().isAvailable()) {
try {
((Lifecycle) connector).start();
} catch (LifecycleException e) {
log.error("Connector.start", e);
}
}
// Report this property change to interested listeners
support.firePropertyChange("connector", null, connector);
}
}

1.给当前入去的Connector主键设置父容器service.
2.根据原有Connector集合的大小加上新加入的容器，从新构建了一个Connector数组。
3.将旧的数据拷贝到新的容器数组中，再添加新加的容器
4.然后根据当前容器的生命状态判断是否要启动新加入的容器
这里存放connector组件为什么用数组而不用List来存放不是太明白。感觉跟server管理service组件操作一样。看完所有的抽象接口是不是感觉有些奇怪，按照前面给的整体架构图怎么没看到给Service添加Engine组件的入口。查看Engine的标准实现类StandardEngine其实是实现了Container接口的，所以这里应该是通过setContainer接口设置进去的，其源码如下：

[html] view plain copy

public void setContainer(Container container) {
Container oldContainer = this.container;
if ((oldContainer != null) && (oldContainer instanceof Engine))
((Engine) oldContainer).setService(null);
this.container = container;
if ((this.container != null) && (this.container instanceof Engine))
((Engine) this.container).setService(this);
if (getState().isAvailable() && (this.container != null)) {
try {
this.container.start();
} catch (LifecycleException e) {
// Ignore
}
}
if (getState().isAvailable() && (oldContainer != null)) {
try {
oldContainer.stop();
} catch (LifecycleException e) {
// Ignore
}
}
// Report this property change to interested listeners
support.firePropertyChange("container", oldContainer, this.container);
}

1.将原有的Container（Engine）对象的父对象置为空
2.同时将旧的Container对象覆盖掉，变成新注入的Container对象
3.同时根据当前组件的生命周期来判断是否将新注入的容器启动

3.Engine组件
Engine接口类为该组件的抽象接口，它继承Container接口跟前面描述的两个组件似乎有些不一样，查看源码后发现Container接口也继承了Lifecycle接口。Engine结构如下图：

技术分享

它的标准实现是StandardEngine类，查setService接口的具体实现，service组件设置进Engine组件中，让两者之间关联。怎么没有看到添加子组件的入口呢？我们查看StandardEngine实现类中，它继承了ContainerBase类，而这个类实现了Container接口。在StandardEngine类中看到了addChild方法的实现如下代码：

[html] view plain copy

@Override
public void addChild(Container child) {
if (!(child instanceof Host))
throw new IllegalArgumentException
(sm.getString("standardEngine.notHost"));
super.addChild(child);
}<span style="font-family:Microsoft YaHei;font-size:12px;">
</span>

通过这个方法来为Engine添加子组件

1.判断当前传入的组件是否是Host类型的，否则抛异常

2.调用服务类中的addChild方法，同时将child变量传递到父类中处理，我们继续看父类ContainerBase中的代码。

[html] view plain copy

public void addChild(Container child) {
if (Globals.IS_SECURITY_ENABLED) {
PrivilegedAction<Void> dp =
new PrivilegedAddChild(child);
AccessController.doPrivileged(dp);
} else {
addChildInternal(child);
}
}
private void addChildInternal(Container child) {
if( log.isDebugEnabled() )
log.debug("Add child " + child + " " + this);
synchronized(children) {
if (children.get(child.getName()) != null)
throw new IllegalArgumentException("addChild: Child name ‘" +
child.getName() +
"‘ is not unique");
child.setParent(this); // May throw IAE
children.put(child.getName(), child);
// Start child
if ((getState().isAvailable() ||
LifecycleState.STARTING_PREP.equals(getState())) &&
startChildren) {
boolean success = false;
try {
child.start();
success = true;
} catch (LifecycleException e) {
log.error("ContainerBase.addChild: start: ", e);
throw new IllegalStateException
("ContainerBase.addChild: start: " + e);
} finally {
if (!success) {
children.remove(child.getName());
}
}
}
fireContainerEvent(ADD_CHILD_EVENT, child);
}
}

最终它调用了addChildInternal方法来处理。

child.setParent(this);
children.put(child.getName(), child);
1.这里传入host子组件的同时，给host子组件设置了父组件
2.将子组件保存在children变量中，这里的children其实就是个HashMap对象。
看到这里也就明白了，所有继承ContainerBase类的组件在添加子组件都是依赖父类中的MAP对象来保存的.

4.Host组件
Host类为该组件的接口定义，也继承了Container类，它的标准实现是StandardHost类，继承ContainerBase类。host结构如下图所示：技术分享

因为该标准实现类StandardHost也继承了ContainerBase类，所以该组件的子组件添加也依赖父类中的Map来保存，跟Engine组件管理子组件是一样的。每一个HOST相当于一个主机，并负责展开和运行多个部署进去的war包。每个主机下面有多个部署的应用，一个应用就对应着一个Context。通过context将多个应用分隔开。所以host的子组件就是context，在通过ContainerBase类的addChild方法来添加context子容器的同时也给它设置了父容器host对象。

5.Context容器

context接口继承了Container，StandardContext类为是Context的标准实现，它也继承了ContainerBase类，所以给改容器注入子容器也是通过containerBase类中的addaddChild来处理的。Context容器代表着一个servlet容器，它为servlet运行提供环境。context管理着里面servlet实例，servlet实例在context中以Wrapper形式存在。那么一个http请求是怎么找到对应的servlet实例的呢？后面章节再来详细描述

技术分享

6.Wrapper容器

Wrapper接口类也继承Container类，它的标准实现类是StandardWrapper，也继承了ContainerBase类。因为Wrapper容器是最底层的容器了，所以它不存在子容器。Wrapper 代表一个Servlet，它负责管理一个 Servlet，包括的 Servlet的装载、初始化、执行以及资源回收。

技术分享

三组件相关类结构

上面小节描述将各个容器编织到一起，阅读相关容器的代码结构可以整理出如下类的继承关系。从类的关系图可以看出所有的容器都实现了Lifecycle接口，该接口定义了控制着tomcat的初始化，启动，停止，销毁等抽象操作。具体的实现都留给了子类实现。

仔细查看上面的结构图，可以发现LifecycleBase比较陌生，在前面章节没怎么提到过。LifecycleBase类实现了Lifecycle接口，它实现了Lifecycle接口中的init()start()stop()destroy()。我们看看LifecycleBase中的类是怎么实现的，源码如下：

[java] view plain copy

/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.catalina.util;
import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.LifecycleListener;
import org.apache.catalina.LifecycleState;
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.apache.tomcat.util.res.StringManager;
/**
* Base implementation of the {@link Lifecycle} interface that implements the
* state transition rules for {@link Lifecycle#start()} and
* {@link Lifecycle#stop()}
*/
public abstract class LifecycleBase implements Lifecycle {
private static Log log = LogFactory.getLog(LifecycleBase.class);
private static StringManager sm =
StringManager.getManager("org.apache.catalina.util");
/**
* Used to handle firing lifecycle events.
* TODO: Consider merging LifecycleSupport into this class.
*/
private LifecycleSupport lifecycle = new LifecycleSupport(this);
/**
* The current state of the source component.
*/
private volatile LifecycleState state = LifecycleState.NEW;
/**
* {@inheritDoc}
*/
@Override
public void addLifecycleListener(LifecycleListener listener) {
lifecycle.addLifecycleListener(listener);
}
/**
* {@inheritDoc}
*/
@Override
public LifecycleListener[] findLifecycleListeners() {
return lifecycle.findLifecycleListeners();
}
/**
* {@inheritDoc}
*/
@Override
public void removeLifecycleListener(LifecycleListener listener) {
lifecycle.removeLifecycleListener(listener);
}
/**
* Allow sub classes to fire {@link Lifecycle} events.
*
* @param type Event type
* @param data Data associated with event.
*/
protected void fireLifecycleEvent(String type, Object data) {
lifecycle.fireLifecycleEvent(type, data);
}
public synchronized final void init() throws LifecycleException {
if (!state.equals(LifecycleState.NEW)) {
invalidTransition(Lifecycle.INIT_EVENT);
}
//1.实现初始化的方法，最终是调用了当前类的initInternal方法,发现
initInternal抽象的
initInternal();
setState(LifecycleState.INITIALIZED);
}
protected abstract void initInternal() throws LifecycleException;
/**
* {@inheritDoc}
*/
@Override
public synchronized final void start() throws LifecycleException {
if (LifecycleState.STARTING_PREP.equals(state) ||
LifecycleState.STARTING.equals(state) ||
LifecycleState.STARTED.equals(state)) {
if (log.isDebugEnabled()) {
Exception e = new LifecycleException();
log.debug(sm.getString("lifecycleBase.alreadyStarted",
toString()), e);
} else if (log.isInfoEnabled()) {
log.info(sm.getString("lifecycleBase.alreadyStarted",
toString()));
}
return;
}
if (state.equals(LifecycleState.NEW)) {
init();
} else if (!state.equals(LifecycleState.INITIALIZED) &&
!state.equals(LifecycleState.STOPPED)) {
invalidTransition(Lifecycle.BEFORE_START_EVENT);
}
setState(LifecycleState.STARTING_PREP);
try {
//2.实现初始化的方法，最终是调用了当前类的startInternal方法,发现startInternal抽象的
startInternal();
} catch (LifecycleException e) {
setState(LifecycleState.FAILED);
throw e;
}
if (state.equals(LifecycleState.FAILED) ||
state.equals(LifecycleState.MUST_STOP)) {
stop();
} else {
// Shouldn‘t be necessary but acts as a check that sub-classes are
// doing what they are supposed to.
if (!state.equals(LifecycleState.STARTING)) {
invalidTransition(Lifecycle.AFTER_START_EVENT);
}
setState(LifecycleState.STARTED);
}
}
/**
* Sub-classes must ensure that:
* <ul>
* <li>the {@link Lifecycle#START_EVENT} is fired during the execution of
* this method</li>
* <li>the state is changed to {@link LifecycleState#STARTING} when the
* {@link Lifecycle#START_EVENT} is fired
* </ul>
*
* If a component fails to start it may either throw a
* {@link LifecycleException} which will cause it‘s parent to fail to start
* or it can place itself in the error state in which case {@link #stop()}
* will be called on the failed component but the parent component will
* continue to start normally.
*
* @throws LifecycleException
*/
protected abstract void startInternal() throws LifecycleException;
/**
* {@inheritDoc}
*/
@Override
public synchronized final void stop() throws LifecycleException {
if (LifecycleState.STOPPING_PREP.equals(state) ||
LifecycleState.STOPPING.equals(state) ||
LifecycleState.STOPPED.equals(state)) {
if (log.isDebugEnabled()) {
Exception e = new LifecycleException();
log.debug(sm.getString("lifecycleBase.alreadyStopped",
toString()), e);
} else if (log.isInfoEnabled()) {
log.info(sm.getString("lifecycleBase.alreadyStopped",
toString()));
}
return;
}
if (state.equals(LifecycleState.NEW)) {
state = LifecycleState.STOPPED;
return;
}
if (!state.equals(LifecycleState.STARTED) &&
!state.equals(LifecycleState.FAILED) &&
!state.equals(LifecycleState.MUST_STOP)) {
invalidTransition(Lifecycle.BEFORE_STOP_EVENT);
}
setState(LifecycleState.STOPPING_PREP);
//3.实现初始化的方法，最终是调用了当前类的stopInternal方法,发现stopInternal抽象的
stopInternal();
if (state.equals(LifecycleState.MUST_DESTROY)) {
// Complete stop process first
setState(LifecycleState.STOPPED);
destroy();
} else {
// Shouldn‘t be necessary but acts as a check that sub-classes are doing
// what they are supposed to.
if (!state.equals(LifecycleState.STOPPING)) {
invalidTransition(Lifecycle.AFTER_STOP_EVENT);
}
setState(LifecycleState.STOPPED);
}
}
/**
* Sub-classes must ensure that:
* <ul>
* <li>the {@link Lifecycle#STOP_EVENT} is fired during the execution of
* this method</li>
* <li>the state is changed to {@link LifecycleState#STOPPING} when the
* {@link Lifecycle#STOP_EVENT} is fired
* </ul>
*
* @throws LifecycleException
*/
protected abstract void stopInternal() throws LifecycleException;
public synchronized final void destroy() throws LifecycleException {
if (LifecycleState.DESTROYED.equals(state)) {
if (log.isDebugEnabled()) {
Exception e = new LifecycleException();
log.debug(sm.getString("lifecycleBase.alreadyDestroyed",
toString()), e);
} else if (log.isInfoEnabled()) {
log.info(sm.getString("lifecycleBase.alreadyDestroyed",
toString()));
}
return;
}
if (!state.equals(LifecycleState.STOPPED) &&
!state.equals(LifecycleState.FAILED) &&
!state.equals(LifecycleState.NEW)) {
invalidTransition(Lifecycle.DESTROY_EVENT);
}
//4.实现初始化的方法，最终是调用了当前类的destroyInternal方法,发现destroyInternal抽象的
destroyInternal();
setState(LifecycleState.DESTROYED);
}
protected abstract void destroyInternal() throws LifecycleException;
/**
* {@inheritDoc}
*/
public LifecycleState getState() {
return state;
}
/**
* Provides a mechanism for sub-classes to update the component state.
* Calling this method will automatically fire any associated
* {@link Lifecycle} event.
*
* @param state The new state for this component
*/
protected synchronized void setState(LifecycleState state) {
setState(state, null);
}
/**
* Provides a mechanism for sub-classes to update the component state.
* Calling this method will automatically fire any associated
* {@link Lifecycle} event.
*
* @param state The new state for this component
* @param data The data to pass to the associated {@link Lifecycle} event
*/
protected synchronized void setState(LifecycleState state, Object data) {
if (log.isDebugEnabled()) {
log.debug(sm.getString("lifecycleBase.setState", this, state));
}
this.state = state;
String lifecycleEvent = state.getLifecycleEvent();
if (lifecycleEvent != null) {
fireLifecycleEvent(lifecycleEvent, data);
}
}
private void invalidTransition(String type) throws LifecycleException {
String msg = sm.getString("lifecycleBase.invalidTransition", type,
toString(), state);
throw new LifecycleException(msg);
}
}

阅读以上LifecycleBase类中的源码，在第1,2,3,4处分别实现了init(),start(),stop(),destroy()等方法。分析其方法体中内容，实现代码最终还是调用了当前类中的initInternal(),startInternal(),stopInternal(),destroyInternal()等方法，而且这些方法还是抽象的。也就是说在执行这些方法时，最终是执行子类的具体实现。这貌似就是设计模式中的抽象模版方法模式哦！

四总结

阅读到这，大家应该对tomcat的整体架构和各个容器如何交织在一起有了一定的了解。并在第三节我粗略的分析了下容器的初始化，启动，停止，销毁等生命周期的控制，从结构上看使用了抽象模版方法模式，所以掌握23种设计模式还是非常有用的在阅读源码或自己做设计方面。了解了这些您是否会再思考，这些容器是什么时候或什么事件来触发装配在一起操作的哇！。下一个章节就来说说容器的初始化吧，它会给出前面的答案！

以上是关于tomcat原理解析：整体架构的主要内容，如果未能解决你的问题，请参考以下文章

Jetty的工作原理解析以及与Tomcat的比较

Netty原理架构解析