Tomcat 源码解析 - tomcat組件之Container和Engine

上篇分析Service我们知道，在Service中主要涉及到Connector和Engine，我们先走Engine这条线，因为这涉及到tomcat内部工作机制，Connector是涉及到http与我们tomcat的连接，这个也是重点以后分析，这篇开始我们将进入Container系统组件，首先要看的Engine，下图是Engine的继承关系。

从上图可以比较清晰的看出StandardEngine的继承关系，所以看Engine组件之前，要大概的看下接口Container和抽象类ContainerBase。

Container接口主要方法：

//接口继承了Lifecycle接口
public interface Container extends Lifecycle {
   //addChild事件，添加的listner可以监听
    public static final String ADD_CHILD_EVENT = "addChild";
    //addValve事件，这个valve是很重要的存在，将来分析tomcat执行http请求流程的时候会重点涉及到
    public static final String ADD_VALVE_EVENT = "addValve";
   // removeChild事件
    public static final String REMOVE_CHILD_EVENT = "removeChild";
// removeValve事件
    public static final String REMOVE_VALVE_EVENT = "removeValve";
………………………..
//这个Pipleline是valve的集合，将来分析tomcat解析请求的时候会重点分析
public Pipeline getPipeline();
//cluster涉及到集群，这个后面也会重点分析
    public Cluster getCluster();

    public void setCluster(Cluster cluster);

//BackgroundProcessorDelay 标记后台任务多久执行一次，如果为负数，child的backgroundProccess都不会被执行
    public int getBackgroundProcessorDelay();

    public void setBackgroundProcessorDelay(int delay);
   ………………….

   //realm也是tomcat提供的一个机制，将来会重点分析
    public Realm getRealm();

    public void setRealm(Realm realm);
    // --------------------------------------------------------- Public Methods
 //执行一个周期性的任务在后台
    public void backgroundProcess();
//下面都是跟child和listener相关的方法
    public void addChild(Container child);
    public void addContainerListener(ContainerListener listener);

    public void addPropertyChangeListener(PropertyChangeListener listener);
    public Container findChild(String name);

    public Container[] findChildren();
    public ContainerListener[] findContainerListeners();
    public void removeChild(Container child);
    public void removeContainerListener(ContainerListener listener);

    public void removePropertyChangeListener(PropertyChangeListener listener);

    public void fireContainerEvent(String type, Object data);
………….
//StartStopThreads？
public int getStartStopThreads();

    public void setStartStopThreads(int startStopThreads);

…………..
}

ContainerBase 类：

从上面继承关系可以看出ContainerBase最终还是实现了LifeCycle，所以我们要重点看的是XXXXInternal几个回调方法，看源码可以发现很多addXXX，get/setXXX方法，从前面的分析我们可以知道这些基本上是Digester解析的时候需要调用的方法。

initInternal 方法：

//总的来说就是实例化startStopExecutor给后面的调用做准备
protected void initInternal() throws LifecycleException {
        BlockingQueue<Runnable> startStopQueue = new LinkedBlockingQueue<>();
        startStopExecutor = new ThreadPoolExecutor(
                getStartStopThreadsInternal(),
                getStartStopThreadsInternal(), 10, TimeUnit.SECONDS,
                startStopQueue,
                new StartStopThreadFactory(getName() + "-startStop-"));
        startStopExecutor.allowCoreThreadTimeOut(true);
        super.initInternal();
}

startInternal 方法：

// synchronized?
protected synchronized void startInternal() throws LifecycleException {
…………………
//获得Digester解析得到的Cluster，并启动
Cluster cluster = getClusterInternal();
if (cluster instanceof Lifecycle) {
    ((Lifecycle) cluster).start();
}
//获得Digester解析得到的Realm，并启动
Realm realm = getRealmInternal();
if (realm instanceof Lifecycle) {
    ((Lifecycle) realm).start();
}

//通过刚才实例化的Executor多线程的来启动child
Container children[] = findChildren();
List<Future<Void>> results = new ArrayList<>();
for (int i = 0; i < children.length; i++) {
    results.add(startStopExecutor.submit(new StartChild(children[i])));
}
//利用Future特性进行失败处理
boolean fail = false;
for (Future<Void> result : results) {
    try {
        result.get();
    } catch (Exception e) {
        log.error(sm.getString("containerBase.threadedStartFailed"), e);
        fail = true;
    }

}
if (fail) {
    throw new LifecycleException(
            sm.getString("containerBase.threadedStartFailed"));
}
//启动pipleline中的valve
if (pipeline instanceof Lifecycle)
    ((Lifecycle) pipeline).start();
setState(LifecycleState.STARTING);

//后面分析
threadStart();

}

现在看下threadStart 方法：

protected void threadStart() {

        if (thread != null)
            return;
//当backgroundProcessorDelay为负数不进行线程调用
        if (backgroundProcessorDelay <= 0)
            return;
//重要标志，标记什么时候不执行ContainerBackgroundProcessor
        threadDone = false;
//设置thread name，设置为Daemon线程，线程内容是ContainerBackgroundProcessor类，
        String threadName = "ContainerBackgroundProcessor[" + toString() + "]";
        thread = new Thread(new ContainerBackgroundProcessor(), threadName);
        thread.setDaemon(true);
        thread.start();

    }

ContainerBackgroundProcessor类：

看源码可以知道处理的是子container的backgroundProcess方法。

stopInternal和destroyInternal方法就是相对应的按大概相反的顺序调用realm ，cluster相对应的stop 、destroy方法。

现在可以开始看Engine了，跟之前一样我们从Catalina的createStartDigester开始来看init过后StandardEngine的对象链以及Server.xml中关于Engine的配置。

上篇我们知道关于Engine的rule是EngineRuleSet。

EngineRuleSet 类：

重点是看addRuleInstances 方法

//解析到Engine标签的时候，创建StandardEngine对象
digester.addObjectCreate(prefix + "Engine",
"org.apache.catalina.core.StandardEngine",
"className");

//设置Engine标签相对应属性给StandardEngine对象
digester.addSetProperties(prefix + "Engine");

//如果Engine标签设置了engineConfigClass属性值，将实例化然后add给engine的LifeCyecleListener，没有设置就默认用EngineConfig类
digester.addRule(prefix + "Engine",
new LifecycleListenerRule
("org.apache.catalina.startup.EngineConfig",
"engineConfigClass"));

//调用Service的setContainer方法，参数为StandardEngine
digester.addSetNext(prefix + "Engine",
"setContainer",
"org.apache.catalina.Engine");

//解析到Engine/Cluster，通过标签上的className属性值实例化Cluster对象
digester.addObjectCreate(prefix + "Engine/Cluster",
null, 
"className");

//设置Cluster标签上相对应的属性值进Cluster对象
digester.addSetProperties(prefix + "Engine/Cluster");

//调用Engine的setCluster方法，参数是Cluster对象
digester.addSetNext(prefix + "Engine/Cluster",
"setCluster",
"org.apache.catalina.Cluster");

//同之前解析Listener
digester.addObjectCreate(prefix + "Engine/Listener",
null,                                 "className");
digester.addSetProperties(prefix + "Engine/Listener");
digester.addSetNext(prefix + "Engine/Listener",
"addLifecycleListener",
"org.apache.catalina.LifecycleListener");

//根据RealmRuleSet规则设置StandardEngine
digester.addRuleSet(new RealmRuleSet(prefix + "Engine/"));

//解析到Engine/Valve标签是通过标签上className属性创建valve对象
digester.addObjectCreate(prefix + "Engine/Valve",
null, 
"className");

//设置标签上相对应属性进Valve
digester.addSetProperties(prefix + "Engine/Valve");

//调用StandardEngine上的addValve方法，参数是实现Valve的对象，这个Valve将添加进container的Pipeline，这个Pipeline是tomcat解析请求流程的重要一员，后面会详细分析。
digester.addSetNext(prefix + "Engine/Valve",
"addValve",
"org.apache.catalina.Valve");

跟之前一样，看StandardEngine ，主要关注XXXInternal几个方法，因为它同时也是Container，所以还要关注另外跟Container相关的方法

看具体方法之前我们先看下Engine接口

public interface Engine extends Container {
    //Engine下默认的childhost
    public String getDefaultHost();

    public void setDefaultHost(String defaultHost);

//跟cluster相关的Engine都要有个jvmroute
    public String getJvmRoute();

    public void setJvmRoute(String jvmRouteId);
//我们的Service 
    public Service getService();
    public void setService(Service service);
}

现在看StandardEngine 相关方法，观察源码，发现XXXInternal不是重点，重点是StandardEngine 的构造方法

public StandardEngine() {

        super();
//设置pipleline的basicValve为StandardEngineValve，后面大概看下StandardEngineValve类，valve类主要是在处理请求的过程中发挥作用
        pipeline.setBasic(new StandardEngineValve());
        try {
//设置JvmRoute
            setJvmRoute(System.getProperty("jvmRoute"));
        } catch(Exception ex) {
            log.warn(sm.getString("standardEngine.jvmRouteFail"));
        }
//设置backgroundProcessorDelay为10，表明Engine会启动线程每隔10×1000 s 来调用它的child的backgroudProcess
        backgroundProcessorDelay = 10;
    }

initInternal 方法：

protected void initInternal() throws LifecycleException {
//确保realm被设置，如果没有配置，设置NullRealm
        getRealm();
        super.initInternal();
}

startInternal 方法：
protected synchronized void startInternal() throws LifecycleException {

//记log
        if(log.isInfoEnabled())
            log.info( "Starting Servlet Engine: " + ServerInfo.getServerInfo());
        super.startInternal();
    }

Valve和Pipeline有必要单独分析，涉及到tomcat请求流程的处理。

**总结：**这篇开始就进入了tomcat的相对核心的部分，新的Container继承链，跟Container相关的有几个重要的类，Valve和Pipeline、Cluster、Realm，都是tomcat提供的一些相对应的特性，后面会有单独分析，每个不同的Container重点在于他们想对应的Valve，渐渐进入核心，目前我们只关注tomcat的启动和停止，关于Valve和Pipeline的分析我们只是介绍方便后面Container的介绍，关于流程的处理后面会专门大篇幅分析，流程的处理的代码比较复杂。

09、Tomcat 源码解析 - tomcat組件之Container和Engine