Tomcat源码分析之Server与Lifecycle的设计与实现

最近看Tomcat的源码的节奏还算是挺紧凑的，给人的感觉，tomcat的代码相对以前读的jetty的代码显得更有条理一些。。。当然这也是有可能是因为自己看的jetty的版本是比较老的，而看的Tomcat的代码却是比较新的Tomcat8的代码。。。。

好了闲话不多说了。。。

先来说说LifeCycle的概念。。。

这个在jetty中也有，组要是用于维护一个组件的生命周期，例如start，stop啥的。。。

另外对于有lifecycle概念的组件，一般也都还有listener的概念，当组件的状态发生改变的时候，可以有listener进行响应。。。

好啦先来看看最上层的LifeCycle接口的定义吧：//生命周期的接口定义
public interface Lifecycle {

//下面定义了一些基本的状态
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";

public static final String CONFIGURE_START_EVENT = "configure_start";

public static final String CONFIGURE_STOP_EVENT = "configure_stop";

// --------------------------------------------------------- Public Methods

/**
* Add a LifecycleEvent listener to this component.
*
* @param listener The listener to add
*/
//添加一个监听器
public void addLifecycleListener(LifecycleListener listener);

/**
* Get 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();

/**
* Remove a LifecycleEvent listener from this component.
*
* @param listener The listener to remove
*/
//移除一个监听器
public void removeLifecycleListener(LifecycleListener listener);

//初始化
public void init() throws LifecycleException;

//启动
public void start() throws LifecycleException;

//停止
public void stop() throws LifecycleException;

/**
* Prepare to discard the object. The following {@link LifecycleEvent}s will
* be fired in the following order:
* <ol>
* <li>DESTROY_EVENT: On the successful completion of component
* destruction.</li>
* </ol>
*
* @exception LifecycleException if this component detects a fatal error
* that prevents this component from being used
*/
//销毁
public void destroy() throws LifecycleException;

/**
* Obtain the current state of the source component.
*
* @return The current state of the source component.
*/
//返回当前的生命周期状态
public LifecycleState getState();

/**
* Obtain a textual representation of the current component state. Useful
* for JMX.
*/
//返回状态的名字
public String getStateName();
}

还是比较简单的吧，先是一些基本的状态和事件的定义，然后接下来是一些基本的操作，例如添加listener，移除listener，启动，停止什么的。。都还算比较的常规。。。

接下来是LifeCycle的抽象层，LifecycleBase。。。

这里就不具体的体贴出它的实现代码了，。。。LifecycleBase直接继承自LifeCycle接口，这里主要是实现了中间添加listener，移除listener的操作，这里可以可以初步理解为这里扩展成了一个listener的容器。。

另外LifecycleBase的定义中，还扩展了基本的启动，停止操作什么的。。。

例如当组件启动的时候，就需要更改当前组件的状态，并调用相应的listener。。。这里就拿初始化的方法来举例子吧： //这里扩展了init方法，这里首先设置当前组件的状态，
@Override
public final synchronized void init() throws LifecycleException {
if (!state.equals(LifecycleState.NEW)) {
invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
}
setStateInternal(LifecycleState.INITIALIZING, null, false); //设置当前的状态为INITIALIZING

try {
initInternal(); //调用该方法用于初始化，具体的实现在子类中
} catch (Throwable t) {
ExceptionUtils.handleThrowable(t);
setStateInternal(LifecycleState.FAILED, null, false);
throw new LifecycleException(
sm.getString("lifecycleBase.initFail",toString()), t);
}

setStateInternal(LifecycleState.INITIALIZED, null, false); //将对象设置为INITIALIZED状态
}

//具体初始化的方法啊，在子类中实现
protected abstract void initInternal() throws LifecycleException;
这里应该代码很容易能理解吧，无非就是对当前组件的装填进行验证，并修改组件的状态，当然在设置组件的状态的时候还伴随着对listener的调用。。。

最后再调用initInternal方法进行初始化，当然这个方法需要在具体的子类中进行实现。。。。

另外这里还要介绍一个比较特殊的LifeCycle的抽象层，LifecycleMBeanBase，它继承了抽象类LifecycleBase类型，其实这里看名字就能够知道这个抽象层要干些啥事情了吧。。。。来看一段代码： protected void initInternal() throws LifecycleException {

// If oname is not null then registration has already happened via
// preRegister().
if (oname == null) {
mserver = Registry.getRegistry(null, null).getMBeanServer(); //获取用到的mbserver

oname = register(this, getObjectNameKeyProperties()); //注册当前组件到mbserver
}
}

嗯，其实就是在组件的初始化的时候对当前组件在JMX上进行注册，具体Tomcat的JMX部分内容，在前面的文章中就已经说过了，这里就不详细说了。。。

也就是说，如果一个类型需要在JMX上进行注册，那么它需要继承LifeCycleMBeanBase抽象类，然后实现其中的几个抽象方法。。。

好啦，到这里位置，LifeCycle部分的内容就算差不多了。。

总的感觉，Tomcat在LifeCycle部分的设计还算是比较简单的。。。。

好啦，接下来来看看Server部分的内容吧。。。首先来看看最顶层的接口的定义：

package org.apache.catalina;

import java.io.File;

import org.apache.catalina.deploy.NamingResourcesImpl;
import org.apache.catalina.startup.Catalina;

//顶层的server接口的定义，继承了生命周期接口
public interface Server extends Lifecycle {

// ------------------------------------------------------------- Properties

/**
* Return the global naming resources.
*/
public NamingResourcesImpl getGlobalNamingResources();

/**
* Set the global naming resources.
*
* @param globalNamingResources The new global naming resources
*/
public void setGlobalNamingResources
(NamingResourcesImpl globalNamingResources);

/**
* Return the global naming resources context.
*/
public javax.naming.Context getGlobalNamingContext();

/**
* Return the port number we listen to for shutdown commands.
*/
public int getPort(); //用于监听shutdown命令的端口

/**
* Set the port number we listen to for shutdown commands.
*
* @param port The new port number
*/
public void setPort(int port); ////用于监听shutdown命令的端口

/**
* Return the address on which we listen to for shutdown commands.
*/
public String getAddress(); //用于监听shutdown命令的地址

/**
* Set the address on which we listen to for shutdown commands.
*
* @param address The new address
*/
public void setAddress(String address); //用于监听shutdown命令的地址

/**
* Return the shutdown command string we are waiting for.
*/
public String getShutdown();

/**
* Set the shutdown command we are waiting for.
*
* @param shutdown The new shutdown command
*/
public void setShutdown(String shutdown);

public ClassLoader getParentClassLoader(); //这个server对象用的classLoader,一般是catalina loader

public void setParentClassLoader(ClassLoader parent);

public Catalina getCatalina(); //获取catalina对象

public void setCatalina(Catalina catalina); //设置用的catalina对象

public File getCatalinaBase(); //一般情况下都是tomcat的根路径

public void setCatalinaBase(File catalinaBase);

public File getCatalinaHome();

public void setCatalinaHome(File catalinaHome);

public void addService(Service service); //添加service对象

public void await();

public Service findService(String name); //根据名字获取某个service

public Service[] findServices(); //获取所有的service

public void removeService(Service service); //删除一个service
}

嗯，其实最顶层的Server接口的定义也很简单，扩展了lifeCycle接口其中最重要的部分无非是对service的添加以及移除。。。

给人最大的干吼就是它是一个service的容器

好啦，接下来来看看最常用的类型StandardServer吧，这里它不光实现了Server接口，还继承了LifecycleMBeanBase类型，这里也就表示StandardServer将会被注册到JMX上面去的。。。

由于它的代码比较长，这里就不直接贴出来了。。来比较重要的属性定义吧： private Service services[] = new Service[0]; //用于保存所有的service，是一个数组啊
private final Object servicesLock = new Object();

嗯，一个service的数组。。。。嗯，容器嘛。。。

好了，这里也就稍微的来看看初始话和启动两个方法的实现吧： protected void initInternal() throws LifecycleException {

super.initInternal(); //父类的init，它里面主要是进行对象在mbserver上面注册当前对象

// Register global String cache
// Note although the cache is global, if there are multiple Servers
// present in the JVM (may happen when embedding) then the same cache
// will be registered under multiple names
onameStringCache = register(new StringCache(), "type=StringCache");

// Register the MBeanFactory
MBeanFactory factory = new MBeanFactory(); //创建MBeanFactory
factory.setContainer(this); //设置当前mbeanfactory的container
onameMBeanFactory = register(factory, "type=MBeanFactory"); //注册mbeanfactory

// Register the naming resources
globalNamingResources.init(); //初始计划名字资源

// Populate the extension validator with JARs from common and shared
// class loaders
if (getCatalina() != null) { //获取catalina对象
ClassLoader cl = getCatalina().getParentClassLoader(); //在bootstrap里面设置成了shareloader
// Walk the class loader hierarchy. Stop at the system class loader.
// This will add the shared (if present) and common class loaders
//加载classLoader里面的路径的资源，这里会向上遍历classLoader
while (cl != null && cl != ClassLoader.getSystemClassLoader()) {
if (cl instanceof URLClassLoader) {
URL[] urls = ((URLClassLoader) cl).getURLs();
for (URL url : urls) {
if (url.getProtocol().equals("file")) {
try {
File f = new File (url.toURI());
if (f.isFile() &&
f.getName().endsWith(".jar")) {
ExtensionValidator.addSystemResource(f);
}
} catch (URISyntaxException e) {
// Ignore
} catch (IOException e) {
// Ignore
}
}
}
}
cl = cl.getParent();
}
}
// Initialize our defined Services
for (int i = 0; i < services.length; i++) { //初始化service
services[i].init();
}
}
首先是初始化，这里最重要的事情其实是对当前包含的所有的service的初始化，另外还有一些其他的操作，注释应该也算是交代的比较清楚吧。。。

//父类中定义的抽象方法扩展了lifecycle的start方法，用于启动当前的对象，这里月就是启动tomcat，其实是启动server的service
@Override
protected void startInternal() throws LifecycleException {

fireLifecycleEvent(CONFIGURE_START_EVENT, null);
setState(LifecycleState.STARTING);

globalNamingResources.start();

// Start our defined Services
synchronized (servicesLock) {
for (int i = 0; i < services.length; i++) { //遍历当前的service，然后启动他们
services[i].start();
}
}
}


启动方法，这里其实最主要的也还是对Service的启动。。。

好了，到这里，Server大体的东西就这些吧，其实干货不多。。。

干活最多的地方应该在Connector部分，不过这个以后再写吧。。。。。