Tomcat中组件的生命周期管理(三)

本文主要目的是自定义举例分析Catalina内部生命周期管理的运作方式以及拿内部具体源码来具体分析

假设我们有一台电脑由主机(我们用cpu表示）和显示器构成，那么我们要运用上篇文章学到的内容，来管理整个电脑的启动和关闭，先看我们对类的定义。

在本例中我们对Lifecycle类进行了部分删减，只保留了关于start和stop的相关事件。

Lifecycle

public interface Lifecycle {

// ----------------------------------------------------- Manifest Constants
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";

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

public void addLifecycleListener(LifecycleListener listener);

public LifecycleListener[] findLifecycleListeners();

public void removeLifecycleListener(LifecycleListener listener);

public void start() throws LifecycleException;

public void stop() throws LifecycleException;

}

同样LifecycleBase类也只保留了start,stop相关方法。

LifecycleBase

public abstract class LifeCycleBase implements Lifecycle {

private LifecycleSupport support = new LifecycleSupport(this);
//组件名称
public String name;

@Override
public void addLifecycleListener(LifecycleListener listener) {
support.addLifecycleListener(listener);
}

@Override
public LifecycleListener[] findLifecycleListeners() {
return support.findLifecycleListeners();
}

@Override
public void removeLifecycleListener(LifecycleListener listener) {
support.removeLifecycleListener(listener);
}

protected void fireLifecycleEvent(String type, Object data) {
support.fireLifecycleEvent(type, data);
}

protected abstract void startInternal() throws LifecycleException;

@Override
public void start() throws LifecycleException {
System.out.println(name + " 准备启动");
fireLifecycleEvent(Lifecycle.BEFORE_START_EVENT, null);
System.out.println(name + " 正在启动");
fireLifecycleEvent(Lifecycle.START_EVENT, null);
startInternal();
System.out.println(name + " 启动完毕");
fireLifecycleEvent(Lifecycle.AFTER_START_EVENT, null);

}

protected abstract void stopInternal() throws LifecycleException;

@Override
public void stop() throws LifecycleException {
System.out.println(name + " 准备关闭");
fireLifecycleEvent(Lifecycle.BEFORE_STOP_EVENT, null);
System.out.println(name + " 正在关闭");
stopInternal();
fireLifecycleEvent(Lifecycle.STOP_EVENT, null);
System.out.println(name + " 关闭完毕");
fireLifecycleEvent(Lifecycle.AFTER_STOP_EVENT, null);
}

}

电脑组成部件 CPU定义

CPU

public class CPU extends LifeCycleBase {
@Override
public void startInternal() throws LifecycleException {
System.out.println(super.name + "在启动过程中负载达到了100%!");
}
@Override
public void stopInternal() throws LifecycleException {
System.out.println(name + "在关闭过程中负载下降到了1%!");
}

public CPU(String name) {
super.name = name;
}
}

电脑组成部件 Monitor定义

Monitor

public class Monitor extends LifeCycleBase {

@Override
public void startInternal() throws LifecycleException {
System.out.println(name + "在启动过程中屏幕很亮！");
}
@Override
public void stopInternal() throws LifecycleException {
System.out.println(name + "在关闭过程中屏幕渐渐暗了下去");
}
public Monitor(String name) {
super.name = name;
}
}

电脑类的定义

Computer

public class Computer extends LifeCycleBase {

private CPU cpu ;
private Monitor monitor;

@Override
public void startInternal() throws LifecycleException {

System.out.println(name + "在启动过程中需要先启动子组件");
if (cpu != null) {
((Lifecycle) cpu).start();
}
if (monitor != null) {
((Lifecycle) monitor).start();
}
}
@Override
public void stopInternal() throws LifecycleException {
System.out.println(name + "在关闭过程中需要先关闭子组件");
if (cpu != null) {
((Lifecycle) cpu).stop();
}
if (monitor != null) {
((Lifecycle) monitor).stop();
}
}

public Computer(String name) {
super.name = name;
}

public void setCpu(CPU cpu) {
this.cpu = cpu;
}

public void setMonitor(Monitor monitor) {
this.monitor = monitor;
}
}

运行类代码

public class MainClass {

public static void main(String[] args) throws Exception {

Computer computer = new Computer("电脑");
CPU cpu = new CPU("CPU");
Monitor monitor = new Monitor("显示器");
computer.setCpu(cpu);
computer.setMonitor(monitor);

cpu.addLifecycleListener(new LifecycleListener() {
@Override
public void lifecycleEvent(LifecycleEvent event) {
if (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
System.out.println("已经监听到 cpu正在准备启动");
}
}
});

monitor.addLifecycleListener(new LifecycleListener() {
@Override
public void lifecycleEvent(LifecycleEvent event) {
if (event.getType().equals(Lifecycle.AFTER_STOP_EVENT)) {
System.out.println("已经监听到显示器已经停止");
}
}
});
//启动
computer.start();
System.out.println("------------------------------------------");
computer.stop();
}

}

运行结果

电脑准备启动
电脑正在启动
电脑在启动过程中需要先启动子组件
CPU 准备启动
已经监听到 cpu正在准备启动
CPU 正在启动
CPU在启动过程中负载达到了100%!
CPU 启动完毕
显示器准备启动
显示器正在启动
显示器在启动过程中屏幕很亮！
显示器启动完毕
电脑启动完毕
------------------------------------------
电脑准备关闭
电脑正在关闭
电脑在关闭过程中需要先关闭子组件
CPU 准备关闭
CPU 正在关闭
CPU在关闭过程中负载下降到了1%!
CPU 关闭完毕
显示器准备关闭
显示器正在关闭
显示器在关闭过程中屏幕渐渐暗了下去
显示器关闭完毕
已经监听到显示器已经停止
电脑关闭完毕

从源码可以看到每个组件的启动都会调用父类的start()方法，而start()方法又会调用本类的startInternal()方法，stop方法类似。在父类的start()方法定义了一些组件共性的动作，而在startInternal()方法中定义了组件自己的特殊动作。并且每个组件都可以自行添加自己的监听器。从运行的代码可以看到，只要设置好每个组件的关系就可以统一管理每个组件的启动关闭了。Catalina中的生命周期管理的模式大概就是这样，下面我们找个具体的类来分析。

我们主要分析start()方法相关，其他类似init(),stop(),destroy()方法都是类似的。我们从前面的文章可以知道Tomcat启动的时候是调用了Bootstrap类的main()方法，而main()方法中最后调用了Catalina类的start()方法，我们查看Catalina类的start()方法，其中

getServer().start();

这一步又调用了StandardServer类的start()方法，从这里就Catalina是最顶层组件，下面所有的组件都开始需要进行生命周期管理了。所以查看StandardServer类的定义

public final class StandardServer extends LifecycleMBeanBase implements Server

再查看LifecycleMBeanBase类的定义

public abstract class LifecycleMBeanBase extends LifecycleBase implements MBeanRegistration

我们在这里就看到了上文介绍的关键类LifecycleBase类。之所以有个LifecycleMBeanBase类横跨在这里主要是因为Tomcat要将组件纳入JMX管理，所以用这个类来实现，这个不再本文的讲解范围之内，所以暂时不讨论，可以当作组件直接继承LifecycleBase类。

既然StandardServer类直接继承了LifecycleBase类，那么Catalina调用StandardServer类的start()方法就是调用LifecycleBase类的start()方法(这样的前提是StandardServer,LifecycleMBeanBase类中没有start()方法，实际上这2个类的确没有实现start()方法)。上篇文章已经分析过LifecycleBase类的start()方法具体源码，因为start()方法中会调用子类的startInternal()方法，所以可以直接查看StandardServer类的startInternal()方法。

@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++) {
services[i].start();
}
}
}

可以看到思路非常简单

触发某个事件(针对自己内部所有监听器)
更改自己组件状态
调用子组件的start()方法，包括globalNamingResources和StandardService。

至于这些子组件什么时候设置到本类中的，读者可以自行发现。

我们可以继续往下再看一点，既然调用了StandardService的start()方法，查看StandardService类的定义。

public class StandardService extends LifecycleMBeanBase implements Service

类似StandardServer，那么直接查看其startInternal()方法。

@Override
protected void startInternal() throws LifecycleException {

if(log.isInfoEnabled())
log.info(sm.getString("standardService.start.name", this.name));
setState(LifecycleState.STARTING);

// Start our defined Container first
if (container != null) {
synchronized (container) {
container.start();
}
}

synchronized (executors) {
for (Executor executor: executors) {
executor.start();
}
}

// Start our defined Connectors second
synchronized (connectorsLock) {
for (Connector connector: connectors) {
try {
// If it has already failed, don't try and start it
if (connector.getState() != LifecycleState.FAILED) {
connector.start();
}
} catch (Exception e) {
log.error(sm.getString(
"standardService.connector.startFailed",
connector), e);
}
}
}
}

虽然代码看起来很多，但是按照上面的思路来看的话，还是那几步。

更改当前组件状态
调用自己子组件的start()方法包含container,connector

看到这里我们就不继续往下看了，因为之前启动的文章都已经分析过了，是不是觉得看到这里对启动的流程理解又上了一层。其实自己看看每个组件的startInternal()方法都是在启动自己的子组件，而组件的子组件可以从哪里找到呢？可以看看Digster那篇文章，疑惑看看server.xml也许会有恍然大悟的感觉，至于具体代码去哪里找，读者可以自行挖掘。

写到这里只能感慨Tomcat设计者设计的精巧，代码的简洁，简直完美！

posted @ 2016-08-28 23:57 coldridgeValley 阅读(1274) 评论(0) 收藏举报

刷新页面返回顶部

coldridgeValley

Tomcat中组件的生命周期管理(三)

公告