How-to-work-by-tomcat

分析Tomcat源码的第一步

首先让我们弄懂Tomcat架构体系

The Server：

Service：

Connectors ：

Engines：

• Host - 虚拟主机，通过其IP地址或主机名来区分

• Contexts - Web Application

Realms：

管理引擎的User Authentication And Authorization(用户身份验证和授权), 通过应用配置，允许管理员对一个资源或一组资源设置权限。

Valves：

A Valve element represents a component that will be inserted into the request processing pipeline for the associated Catalina container (Engine, Host, or Context). Individual Valves have distinct processing capabilities

每个层级的容器（Engine, Host、Context, Wrapper ）均有对应的基础Valve实现，同时维护了一个Pipeline实例，我们可以在任何层级的容器 上针对请求处理进行扩展https://zhuanlan.zhihu.com/p/127824362

• Access Log org.apache.catalina.valves.AccessLogValve 它创建日志文件以跟踪客户端访问信息。

• Remote Address Filter org.apache.catalina.filters.RemoteAddrFilter 允许将提交请求的客户机的IP地址与一个或多个正则表达式进行比较，并允许该请求继续或拒绝处理来自此客户机的请求。

• Remote Host Filter org.apache.catalina.filters.RemoteHostFilter 允许将提交此请求的客户机的主机名与一个或多个正则表达式进行比较，并允许请求继续或拒绝处理来自此客户机的请求

• Request Dumper org.apache.catalina.filters.RequestDumperFilter 记录来自请求和响应对象的信息
更多详细的可以在官方文档找到
<http://tomcat.apache.org/tomcat-9.0-doc/config/filter.html

Loggers：

JVM中的类加载机制

verbose:class

1. Boostrap ClassLoader （jre.jar or specify parameters）
• Xbootclasspath 参数指定

2. Extension ClassLoader (jre*.jar or specify parameters)
java.ext.dirs 系统变量所指定的路径下的jar

3. Application ClassLoader (classpath)

      Bootstrap
          |
       System
          |
       Common
       /     \
  Webapp1   Webapp2 ...

• Bootstrap
该类加载器包含Java虚拟机提供的基本运行时类，以及系统扩展目录（$ JAVA_HOME / jre / lib / ext）中存在的JAR文件中的所有类。 注意：某些JVM可能将其实现为多个类加载器，或者可能根本不可见（作为类加载器）

• System
这个类装入器通常是从类路径环境变量的内容初始化的。所有这些类对Tomcat内部类和web应用程序都是可见的。但是，标准的Tomcat启动脚本($CATALINA_HOME/bin/catalina.sh或%CATALINA_HOME%.bat)完全忽略了类路径环境变量本身的内容，而是从以下库构建系统类加载器:
$CATALINA_HOME/bin/bootstrap.jar -包含用于初始化Tomcat服务器的main()方法，以及它所依赖的类加载器实现类
$ CATALINA_BASE / bin / tomcat-juli.jar或$ CATALINA_HOME / bin / tomcat-juli.jar —记录实现类。 其中包括对java.util.logging API的增强类，称为Tomcat JULI
$ CATALINA_HOME / bin / commons-daemon.jar — Apache Commons Daemon项目中的类。 这

• Common
该类加载器包含让Tomcat内部类和所有Web应用程序都可用的类
通常，不应将应用程序类放在这里。 此类加载器搜索的位置由$ CATALINA_BASE / conf / catalina.properties中的common.loader属性定义。 默认设置将按列出的顺序搜索以下位置：
$ CATALINA_BASE / lib中解压缩的类和资源
$ CATALINA_BASE / lib中的JAR文件
$ CATALINA_HOME / lib中解压缩的类和资源
$ CATALINA_HOME / lib中的JAR文件
默认情况，会加载tomcat/bin的所有jar包。

• WebappX
为在单个Tomcat实例中部署的每个Web应用程序创建的一个类加载器。 Web应用程序的/ WEB-INF / classes目录中的所有解压缩的类和资源，以及Web应用程序的/ WEB-INF / lib目录下的JAR文件中的类和资源，这些类和资源对应用程序是可访问的，但是外部是不能访问的。

也就是说不同的Web应用程序是不能互相访问的

Catalina   负责加载Tomcat内部的类
Shared     负责加载Tomcat下所有Web应用程序复用类

通过保存一个Object的引用，再用反射去调用了Catalina.load()，实现了代码的解耦。

Servier.xml的加载与解析

在加载完TomcatBaseConfig之后，也会加载一个组件[Digester]

Digester主要是对SAX的封装和抽象

<Server port="8005" shutdown="SHUTDOWN">  <Listener className="org.apache.catalina.startup.VersionLoggerListener" /></>

// Configure the actions we will be using
digester.addObjectCreate("Server",
                         "org.apache.catalina.core.StandardServer",
                         "className");
digester.addSetProperties("Server");
digester.addSetNext("Server", "setServer","org.apache.catalina.Server");

初始化生命周期组件 LifeCycle

public interface Lifecycle {    // ----------------------------------------------------- Manifest Constants    /**     * The LifecycleEvent type for the "component before init" event.     */    public static final String BEFORE_INIT_EVENT = "before_init";    /**     * The LifecycleEvent type for the "component after init" event.     */    public static final String AFTER_INIT_EVENT = "after_init";    /**     * The LifecycleEvent type for the "component start" event.     */    public static final String START_EVENT = "start";    /**     * The LifecycleEvent type for the "component before start" event.     */    public static final String BEFORE_START_EVENT = "before_start";    /**     * The LifecycleEvent type for the "component after start" event.     */    public static final String AFTER_START_EVENT = "after_start";    /**     * The LifecycleEvent type for the "component stop" event.     */    public static final String STOP_EVENT = "stop";    /**     * The LifecycleEvent type for the "component before stop" event.     */    public static final String BEFORE_STOP_EVENT = "before_stop";    /**     * The LifecycleEvent type for the "component after stop" event.     */    public static final String AFTER_STOP_EVENT = "after_stop";    /**     * The LifecycleEvent type for the "component after destroy" event.     */    public static final String AFTER_DESTROY_EVENT = "after_destroy";    /**     * The LifecycleEvent type for the "component before destroy" event.     */    public static final String BEFORE_DESTROY_EVENT = "before_destroy";    /**     * The LifecycleEvent type for the "periodic" event.     */    public static final String PERIODIC_EVENT = "periodic";    /**     * The LifecycleEvent type for the "configure_start" event. Used by those     * components that use a separate component to perform configuration and     * need to signal when configuration should be performed - usually after     * {@link #BEFORE_START_EVENT} and before {@link #START_EVENT}.     */    public static final String CONFIGURE_START_EVENT = "configure_start";    /**     * The LifecycleEvent type for the "configure_stop" event. Used by those     * components that use a separate component to perform configuration and     * need to signal when de-configuration should be performed - usually after     * {@link #STOP_EVENT} and before {@link #AFTER_STOP_EVENT}.     */    public static final String CONFIGURE_STOP_EVENT = "configure_stop";    // --------------------------------------------------------- Public Methods    /**     * 添加监听器     *     * @param listener The listener to add     */    public void addLifecycleListener(LifecycleListener listener);    /**     * 获取所有的监听器     *     * @return An array containing the life cycle listeners associated with this     *         life cycle. If this component has no listeners registered, a     *         zero-length array is returned.     */    public LifecycleListener[] findLifecycleListeners();    /**     * 移除当前的监听器     *     * @param listener The listener to remove     */    public void removeLifecycleListener(LifecycleListener listener);    /**     * 初始化方法，在INIT_EVENT成功之后执行     *     * @exception LifecycleException if this component detects a fatal error     *  that prevents this component from being used     */    public void init() throws LifecycleException;    /**     * 启动方法，在调用public之外的方法之前。执行顺序BEFORE_START_EVENT、START_EVENT、             * AFTER_START_EVENT     */    public void start() throws LifecycleException;    /**     * 在STOP_EVENT时触发，优雅的关闭。     */    public void stop() throws LifecycleException;    /**     * 在完成DESTROY_EVENT状态时，调用销毁方法     */    public void destroy() throws LifecycleException;    /**     * 获取当前组件的生命周期状态     */    public LifecycleState getState();    /**      * 获取String类型的生命周期状态     */    public String getStateName();    /**     * Marker interface used to indicate that the instance should only be used     * once. Calling {@link #stop()} on an instance that supports this interface     * will automatically call {@link #destroy()} after {@link #stop()}     * completes.     */    public interface SingleUse {    }}

组件的生命周期

public enum LifecycleState {        NEW(false, null),  //新状态        INITIALIZING(false, Lifecycle.BEFORE_INIT_EVENT), //正在初始化        INITIALIZED(false, Lifecycle.AFTER_INIT_EVENT),  //初始化完毕        STARTING_PREP(false, Lifecycle.BEFORE_START_EVENT), //开始启动        STARTING(true, Lifecycle.START_EVENT), //启动中        STARTED(true, Lifecycle.AFTER_START_EVENT), //启动完毕        STOPPING_PREP(true, Lifecycle.BEFORE_STOP_EVENT), //准备停止        STOPPING(false, Lifecycle.STOP_EVENT), //停止中        STOPPED(false, Lifecycle.AFTER_STOP_EVENT), //已停止        DESTROYING(false, Lifecycle.BEFORE_DESTROY_EVENT), //正在释放or正在销毁        DESTROYED(false, Lifecycle.AFTER_DESTROY_EVENT), //已消亡        FAILED(false, null); //失败    private final boolean available;    private final String lifecycleEvent;    private LifecycleState(boolean available, String lifecycleEvent) {        this.available = available;        this.lifecycleEvent = lifecycleEvent;    }    /**     * May the public methods other than property getters/setters and lifecycle     * methods be called for a component in this state? It returns     * <code>true</code> for any component in any of the following states:     * <ul>     * <li>{@link #STARTING}</li>     * <li>{@link #STARTED}</li>     * <li>{@link #STOPPING_PREP}</li>     * </ul>     *     * @return <code>true</code> if the component is available for use,     *         otherwise <code>false</code>     */    public boolean isAvailable() {        return available;    }    public String getLifecycleEvent() {        return lifecycleEvent;    }}

/** * General event for notifying listeners of significant changes on a component * that implements the Lifecycle interface. * * @author Craig R. McClanahan */public final class LifecycleEvent extends EventObject {    private static final long serialVersionUID = 1L;    /**     * Construct a new LifecycleEvent with the specified parameters.     *     * @param lifecycle Component on which this event occurred     * @param type Event type (required)     * @param data Event data (if any)     */    public LifecycleEvent(Lifecycle lifecycle, String type, Object data) {        super(lifecycle);        this.type = type;        this.data = data;    }    /**     * The event data associated with this event.     */    private final Object data;    /**     * The event type this instance represents.     */    private final String type;    /**     * @return the event data of this event.     */    public Object getData() {        return data;    }    /**     * @return the Lifecycle on which this event occurred.     */    public Lifecycle getLifecycle() {        return (Lifecycle) getSource();    }    /**     * @return the event type of this event.     */    public String getType() {        return this.type;    }}

LifecycleBase

public abstract class LifecycleBase implements Lifecycle {}

Base implementation of the Lifecycle interface that implements the

state transition rules for start() and stop()

@Override
public final synchronized void init() throws LifecycleException {
    if (!state.equals(LifecycleState.NEW)) {
        invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
    }

    try {
        setStateInternal(LifecycleState.INITIALIZING, null, false);
        initInternal();  //各个子类实现protected该方法初始化组件
        setStateInternal(LifecycleState.INITIALIZED, null, false);
    } catch (Throwable t) {
        handleSubClassException(t, "lifecycleBase.initFail", toString());
    }
}

public interface LifecycleListener {


    /**
     * Acknowledge the occurrence of the specified event.
     *
     * @param event LifecycleEvent that has occurred
     */
    public void lifecycleEvent(LifecycleEvent event);


}

/**
 * Helper class used to initialize and populate the JNDI context associated
 * with each context and server.
 *
 * @author Remy Maucherat
 */
public class NamingContextListener
        implements LifecycleListener, ContainerListener, PropertyChangeListener {
}

Tomcat Request对象的生成

• > ErrorReportValue->StandardHostValue->AuthenticatorBase->StandardContextValue->StandardWrapperValue->ApplicationFilterChain->ErrorPageFilter->最终到达HttpServlet

连接器与容器的桥梁——CoyoteAdapter

未完………..