tomcat解析(十一)StandardEngine.start

首先是构造方法:
 /** * Create a new StandardEngine component with the default basic Valve. */ public StandardEngine() { super(); pipeline.setBasic(new StandardEngineValve()); /* Set the jmvRoute using the system property jvmRoute */ try { setJvmRoute(System.getProperty("jvmRoute")); } catch(Exception ex) { } // By default, the engine will hold the reloading thread backgroundProcessorDelay = 10; }

从层级上来看StandardEngine在StandardService之下,而在StandardEngine之下的还有StandardHost及StandardContext,其中StandardEngine,StandardHost及StandardContext继承自ContainerBase类,而该类持有一个管道变量
  /**
     * The Pipeline object with which this Container is associated.
     */
    protected Pipeline pipeline = new StandardPipeline(this);
    而StandardEngine的构造方法则是为其设置了new StandardEngineValve()的对象,具体有何作用,后续再讲
这里先看一下start方法的代码:
/** * Start this Engine component. * * @exception LifecycleException if a startup error occurs */ public void start() throws LifecycleException { if( started ) { return; } if( !initialized ) { init(); } // Look for a realm - that may have been configured earlier. // If the realm is added after context - it'll set itself. if( realm == null ) { ObjectName realmName=null; try { realmName=new ObjectName( domain + ":type=Realm"); if( mserver.isRegistered(realmName ) ) { mserver.invoke(realmName, "init", new Object[] {}, new String[] {} ); } } catch( Throwable t ) { log.debug("No realm for this engine " + realmName); } } // Log our server identification information //System.out.println(ServerInfo.getServerInfo()); if(log.isInfoEnabled()) log.info( "Starting Servlet Engine: " + ServerInfo.getServerInfo()); if( mbeans != null ) { try { Registry.getRegistry(null, null) .invoke(mbeans, "start", false); } catch (Exception e) { log.error("Error in start() for " + mbeansFile, e); } } // Standard container startup super.start(); }  

    其中init()方法如下:
    public void init() { if( initialized ) return; initialized=true; if( oname==null ) { // not registered in JMX yet - standalone mode try { if (domain==null) { domain=getName(); } if(log.isDebugEnabled()) log.debug( "Register " + domain ); oname=new ObjectName(domain + ":type=Engine"); controller=oname; Registry.getRegistry(null, null) .registerComponent(this, oname, null); } catch( Throwable t ) { log.info("Error registering ", t ); } } if( mbeansFile == null ) { String defaultMBeansFile=getBaseDir() + "/conf/tomcat5-mbeans.xml"; File f=new File( defaultMBeansFile ); if( f.exists() ) mbeansFile=f.getAbsolutePath(); } if( mbeansFile != null ) { readEngineMbeans(); } if( mbeans != null ) { try { Registry.getRegistry(null, null).invoke(mbeans, "init", false); } catch (Exception e) { log.error("Error in init() for " + mbeansFile, e); } } if( service==null ) { // for consistency...: we are probably in embeded mode try { service=new StandardService(); service.setContainer( this ); service.initialize(); } catch( Throwable t ) { log.error(t); } } }  

    除了注册MBean外,还有一段service.initialize的调用,上一篇已讲过,调用StandardService.setContainer方法时除了会将StandardEngine设置到StandardService的container对象中外,还会将StandardService对象设置到StandardEngine的service对象,因此这段代码其实是又调用了StandardService类的initialize方法,从上一篇的代码中可以看到,该方法被调用的时候都会判断一下是否被调用过,因此其实这里不会重复执行StandardService的初始化内容
    在运行完init方法后.又做了一些MBean注册的动作,最后调用了super.start(),让我们看看父类ContainerBase的start()方法里做了什么
    /** * Prepare for active use of the public methods of this Component. * * @exception LifecycleException if this component detects a fatal error * that prevents it from being started */ public synchronized void start() throws LifecycleException { // Validate and update our current component state if (started) { if(log.isInfoEnabled()) log.info(sm.getString("containerBase.alreadyStarted", logName())); return; } // Notify our interested LifecycleListeners lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null); started = true; // Start our subordinate components, if any if ((loader != null) && (loader instanceof Lifecycle)) ((Lifecycle) loader).start(); logger = null; getLogger(); if ((logger != null) && (logger instanceof Lifecycle)) ((Lifecycle) logger).start(); if ((manager != null) && (manager instanceof Lifecycle)) ((Lifecycle) manager).start(); if ((cluster != null) && (cluster instanceof Lifecycle)) ((Lifecycle) cluster).start(); if ((realm != null) && (realm instanceof Lifecycle)) ((Lifecycle) realm).start(); if ((resources != null) && (resources instanceof Lifecycle)) ((Lifecycle) resources).start(); // Start our child containers, if any Container children[] = findChildren(); for (int i = 0; i < children.length; i++) { if (children[i] instanceof Lifecycle) ((Lifecycle) children[i]).start(); } // Start the Valves in our pipeline (including the basic), if any if (pipeline instanceof Lifecycle) ((Lifecycle) pipeline).start(); // Notify our interested LifecycleListeners lifecycle.fireLifecycleEvent(START_EVENT, null); // Start our thread threadStart(); // Notify our interested LifecycleListeners lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null); }

主要内容有四部分:
1.lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
触发一个BEFORE_START_EVENT事件,这里我们需要知道注册为StandardEngine的监听器类为何类,可看生成StandardEngine类的Rule设置处,Catalina.createStartDigester处有
 digester.addRuleSet(new EngineRuleSet("Server/Service/"));
EngineRuleSet里有如下代码:
 digester.addObjectCreate(prefix + "Engine", "org.apache.catalina.core.StandardEngine", "className"); digester.addSetProperties(prefix + "Engine"); digester.addRule(prefix + "Engine", new LifecycleListenerRule ("org.apache.catalina.startup.EngineConfig", "engineConfigClass"));

可以看到其listener类型为org.apache.catalina.startup.EngineConfig,其事件处理的实现如下:
/** * Process the START event for an associated Engine. * * @param event The lifecycle event that has occurred */ public void lifecycleEvent(LifecycleEvent event) { // Identify the engine we are associated with try { engine = (Engine) event.getLifecycle(); } catch (ClassCastException e) { log.error(sm.getString("engineConfig.cce", event.getLifecycle()), e); return; } // Process the event that has occurred if (event.getType().equals(Lifecycle.START_EVENT)) start(); else if (event.getType().equals(Lifecycle.STOP_EVENT)) stop(); }  

    而EngineConfig类没有对BEFORE_START_EVENT事件进行处理,因此这里无做啥事
2.调用其持有的loader,manager,cluster,realm,resources,children,pipeline的start()方法
我们将主要看一下children.start,涉及到服务器启动主要流程的内容,但children从何而来呢?可以看到是由standardEngine的addChild方法设置 进来的,但它是什么时候调用的呢?它是解析<Host>标签时触发的,可以看看Catalina.createStartDigester下有
 digester.addRuleSet(new HostRuleSet("Server/Service/Engine/"));
 HostRuleSet中有如下代码:
 digester.addObjectCreate(prefix + "Host", "org.apache.catalina.core.StandardHost", "className"); digester.addSetProperties(prefix + "Host"); digester.addRule(prefix + "Host", new CopyParentClassLoaderRule()); digester.addRule(prefix + "Host", new LifecycleListenerRule ("org.apache.catalina.startup.HostConfig", "hostConfigClass")); digester.addSetNext(prefix + "Host", "addChild", "org.apache.catalina.Container");

可以看到实例化了StandardHost对象,并设置了其监听器类型为org.apache.catalina.startup.HostConfig,并且调用了StandardEngine.addChild方法,因此此处将调用StandardHost.start()
3.lifecycle.fireLifecycleEvent(START_EVENT, null);
触发一个START_EVENT事件,该事件对应调用其start()方法,如下:
/** * Process a "start" event for this Engine. */ protected void start() { if (engine.getLogger().isDebugEnabled()) engine.getLogger().debug(sm.getString("engineConfig.start")); }  

    也就打了一句log
4.threadStart();内容如下:
 /** * Start the background thread that will periodically check for * session timeouts. */ protected void threadStart() { if (thread != null) return; if (backgroundProcessorDelay <= 0) return; threadDone = false; String threadName = "ContainerBackgroundProcessor[" + toString() + "]"; thread = new Thread(new ContainerBackgroundProcessor(), threadName); thread.setDaemon(true); thread.start(); } ContainerBackgroundProcessor类如下: /** * Private thread class to invoke the backgroundProcess method * of this container and its children after a fixed delay. */ protected class ContainerBackgroundProcessor implements Runnable { public void run() { while (!threadDone) { try { Thread.sleep(backgroundProcessorDelay * 1000L); } catch (InterruptedException e) { ; } if (!threadDone) { Container parent = (Container) getMappingObject(); ClassLoader cl = Thread.currentThread().getContextClassLoader(); if (parent.getLoader() != null) { cl = parent.getLoader().getClassLoader(); } processChildren(parent, cl); } } } protected void processChildren(Container container, ClassLoader cl) { try { if (container.getLoader() != null) { Thread.currentThread().setContextClassLoader (container.getLoader().getClassLoader()); } container.backgroundProcess(); } catch (Throwable t) { log.error("Exception invoking periodic operation: ", t); } finally { Thread.currentThread().setContextClassLoader(cl); } Container[] children = container.findChildren(); for (int i = 0; i < children.length; i++) { if (children[i].getBackgroundProcessorDelay() <= 0) { processChildren(children[i], cl); } } } }

可以看到,该线程递归运行相应容器类的container.backgroundProcess方法,而它则会运行ContainerBase的backgroundProcess方法,如下:
    /** * Execute a periodic task, such as reloading, etc. This method will be * invoked inside the classloading context of this container. Unexpected * throwables will be caught and logged. */ public void backgroundProcess() { if (!started) return; if (cluster != null) { try { cluster.backgroundProcess(); } catch (Exception e) { log.warn(sm.getString("containerBase.backgroundProcess.cluster", cluster), e); } } if (loader != null) { try { loader.backgroundProcess(); } catch (Exception e) { log.warn(sm.getString("containerBase.backgroundProcess.loader", loader), e); } } if (manager != null) { try { manager.backgroundProcess(); } catch (Exception e) { log.warn(sm.getString("containerBase.backgroundProcess.manager", manager), e); } } if (realm != null) { try { realm.backgroundProcess(); } catch (Exception e) { log.warn(sm.getString("containerBase.backgroundProcess.realm", realm), e); } } Valve current = pipeline.getFirst(); while (current != null) { try { current.backgroundProcess(); } catch (Exception e) { log.warn(sm.getString("containerBase.backgroundProcess.valve", current), e); } current = current.getNext(); } lifecycle.fireLifecycleEvent(Lifecycle.PERIODIC_EVENT, null); }

这些方法都是一些后台处理的操作,其实与服务器启动主流程没有太多的关系,但有一点需要了解的是
    lifecycle.fireLifecycleEvent(Lifecycle.PERIODIC_EVENT, null);
    这行代码将触发一个Lifecycle.PERIODIC_EVENT的事件,在HostConfig类中(该类为StandardHost的Lifecycle监听器),因为StandardHost与StandardEngine继承一样的父类,因此在StandardHost的start方法中调用super.start后也将触发一样的事件,而事件的监听者则为HostConfig,通过监听此事件将运行其check方法,如下:
   /** * Check status of all webapps. */ protected void check() { if (host.getAutoDeploy()) { // Check for resources modification to trigger redeployment DeployedApplication[] apps = (DeployedApplication[]) deployed.values().toArray(new DeployedApplication[0]); for (int i = 0; i < apps.length; i++) { if (!isServiced(apps[i].name)) checkResources(apps[i]); } // Hotdeploy applications deployApps(); } }

该方法将重新扫描各个context,若有变化,则会重新进行部署
5.lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
触发一个AFTER_START_EVENT事件,具体仍看org.apache.catalina.startup.EngineConfig类的处理,刚才已看过啦,还是啥事没干