Tomcat源码分析之—组件启动实现分析

23decxf

　　Tomcat由多个组件组成，那么Tomcat是怎么对他们的生命周期进行管理的么，这里将从Tomcat源码去分析其生命周期的实现；
　　Bootstrape类为Tomcat的入口，所有的组件够通过实现Lifecycle接口来管理生命周期，Tomcat启动的时候只需调用Server容器的start()，然后父容器依序启动他所包含的子容器，关闭也是如此。
　　通过阅读源码可知一个Server里包含一个或多个Service，一个Service里包含一个Container，一个或多个Connector、Container又包含了Engine、Host、Context、Wrapper四个容器；
　　​
　　Tomcat的组件启动顺序为：
　　StandardServer.start()——》StandardServer.startInternal() ——》StandardService().start()——StandardService.startInternal() ——>》StandardEngine().start() ——》StandardEngine.startInternal()—》StandardEngine中启动其他组件，组件关闭也是如此；
　　
　　现在我们通过Demo简单模拟Tomcat的启动
　　

　　模拟Demo UML类图

　　
　　模拟Demo时序图
　　
　　主要代码段如下：
　　Catalina类：

package co.solinx.Pattern.Observer;
/**
* Created by LX on 2014/11/26.
*/
public class Catalina {
public static void main(String[] args) {
//Tomcat为多个组件组成的server为最外围最大的一个
StandardServer server = new StandardServer();
        //为server添加监听器
server.addLifecycleListener(new ContextConfig());
//添加一个service
StandardService service = new StandardService();
server.AddService(service);
       //为service添加监听器
service.addLifecycleListener(new ContextConfig());
//添加一个engine
StandardEngine standardEngine = new StandardEngine();
        //为engine添加监听器
standardEngine.addLifecycleListener(new EngineConfig());
StandardHost standardHost = new StandardHost("localhost");
//        StandardHost testHost = new StandardHost("test");
//        standardHost.addLifecycleListener(new EngineConfig());
standardEngine.addChild("localhost", standardHost);
//        standardEngine.addChild("test", testHost);
//往service添加engine容器
service.setContainer(standardEngine);
try {
server.start();
} catch (LifecycleException e) {
e.printStackTrace();
}
}
}

　　StandardServer类
　　

package co.solinx.Pattern.Observer;
/**
* Created by LX on 2014/11/26.
*/
public class StandardServer extends LifecycleBase implements Context {
Service services[] = new Service[0];
@Override
protected void startInternal() throws LifecycleException {
for (int i = 0; i < services.length; i++) {
services.start();
}
System.out.println("StandardServer start");
}
public void AddService(Service service) {
Service result[] = new Service[services.length + 1];
System.arraycopy(services, 0, result, 0, services.length);
result[services.length] = service;
services = result;
}   
}
　　StandardService类：
　　

package co.solinx.Pattern.Observer;
/**
* Created by LX on 2014/11/26.
*/
public class StandardService extends LifecycleBase implements Service, Context {
protected ContainerBase container = null;
@Override
protected void startInternal() throws LifecycleException {
container.start();
System.out.println("StandardService start");
}
public void setContainer(ContainerBase container) {
this.container = container;
}
}
　　StandardEngine类：
　　
　　

package co.solinx.Pattern.Observer;
/**
* Created by LX on 2014/11/26.
*/
public class StandardEngine extends ContainerBase {
@Override
protected void startInternal() throws LifecycleException {
super.startInternal();
System.out.println("StandardEngine start");
}
protected void addChild(String key, Container container) {
super.addChild(key, container);
}
}
　　LifecycleSupport类：
　　
　　

package co.solinx.Pattern.Observer;
/**
* Created by LX on 2014/11/26.
* 代理了具体监听者
*/
public class LifecycleSupport {
public LifecycleSupport(Lifecycle lifecycle) {
super();
this.lifecycle = lifecycle;
}
private Lifecycle lifecycle = null;
private LifecycleListener listeners[] = new LifecycleListener[0];
private final Object listenersLock = new Object(); // Lock object for changes to listeners
public void addLifecycleListener(LifecycleListener listener) {
synchronized (listenersLock) {
LifecycleListener results[] =
new LifecycleListener[listeners.length + 1];
for (int i = 0; i < listeners.length; i++)
results = listeners;
results[listeners.length] = listener;
listeners = results;
}
}
public LifecycleListener[] findLifecycleListeners() {
return listeners;
}
public void fireLifecycleEvent(String type, Object data) {
LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);
LifecycleListener interested[] = listeners;
for (int i = 0; i < interested.length; i++)
interested.lifecycleEvent(event);
}
public void removeLifecycleListener(LifecycleListener listener) {
synchronized (listenersLock) {
int n = -1;
for (int i = 0; i < listeners.length; i++) {
if (listeners == listener) {
n = i;
break;
}
}
if (n < 0)
return;
LifecycleListener results[] =
new LifecycleListener[listeners.length - 1];
int j = 0;
for (int i = 0; i < listeners.length; i++) {
if (i != n)
results[j++] = listeners;
}
listeners = results;
}
}
}
　　
　　
　　模拟程序运行结果：

　　文章首发地址：Solinx
　　http://www.solinx.co/archives/86