1.LifyCycle接口
Tomcat通过org.apache.catalina.Lifecycle接口统一管理生命周期,所有生命周期的组件都要实现这个接口。Lifycycle接口一共做了四件事:
1.1定义了13个String类型的常量,用于LifecycleEvent事件中type的属性,作用是区分发出事件的状态(初始化,启动前后)
1.2定义了三个管理监听器LifecycleListener的方法,分别用来添加,查找和删除监听器
1.3定义了四个生命周期的方法init,start,stop,destroy
1.4定义了获取当前状态的两个方法getState和getStateName
源码:
package org.apache.catalina;
public interface Lifecycle {
String BEFORE_INIT_EVENT = "before_init";
String AFTER_INIT_EVENT = "after_init";
String START_EVENT = "start";
String BEFORE_START_EVENT = "before_start";
String AFTER_START_EVENT = "after_start";
String STOP_EVENT = "stop";
String BEFORE_STOP_EVENT = "before_stop";
String AFTER_STOP_EVENT = "after_stop";
String AFTER_DESTROY_EVENT = "after_destroy";
String BEFORE_DESTROY_EVENT = "before_destroy";
String PERIODIC_EVENT = "periodic";
String CONFIGURE_START_EVENT = "configure_start";
String CONFIGURE_STOP_EVENT = "configure_stop";
void addLifecycleListener(LifecycleListener var1);
LifecycleListener[] findLifecycleListeners();
void removeLifecycleListener(LifecycleListener var1);
void init() throws LifecycleException;
void start() throws LifecycleException;
void stop() throws LifecycleException;
void destroy() throws LifecycleException;
LifecycleState getState();
String getStateName();
public interface SingleUse {
}
}
2.LifycycleBase抽象类
Lifecycle的默认实现是org.apache.catalina.util.LifecycleBase,
监听器是通过LifecycleSupport类中定义了一个LifecycleListener数据来保存所有的监听器。
生命周期方法中设置了相应的状态并调用了相应的模板方法init,start,stop,destroy所对应的模板方法分别是initInternal,startInternal,stopInternal,destroyInternal方法,这四个方法都是由子类具体实现
源码:
public abstract class LifecycleBase implements Lifecycle {
private static final Log log = LogFactory.getLog(LifecycleBase.class);
private static final StringManager sm = StringManager.getManager(LifecycleBase.class);
private final List<LifecycleListener> lifecycleListeners = new CopyOnWriteArrayList();
private volatile LifecycleState state;
private boolean throwOnFailure;
public LifecycleBase() {
this.state = LifecycleState.NEW;
this.throwOnFailure = true;
}
public boolean getThrowOnFailure() {
return this.throwOnFailure;
}
public void setThrowOnFailure(boolean throwOnFailure) {
this.throwOnFailure = throwOnFailure;
}
public void addLifecycleListener(LifecycleListener listener) {
this.lifecycleListeners.add(listener);
}
public LifecycleListener[] findLifecycleListeners() {
return (LifecycleListener[])this.lifecycleListeners.toArray(new LifecycleListener[0]);
}
public void removeLifecycleListener(LifecycleListener listener) {
this.lifecycleListeners.remove(listener);
}
protected void fireLifecycleEvent(String type, Object data) {
LifecycleEvent event = new LifecycleEvent(this, type, data);
Iterator var4 = this.lifecycleListeners.iterator();
while(var4.hasNext()) {
LifecycleListener listener = (LifecycleListener)var4.next();
listener.lifecycleEvent(event);
}
}
public final synchronized void init() throws LifecycleException {
if (!this.state.equals(LifecycleState.NEW)) {
this.invalidTransition("before_init");
}
try {
this.setStateInternal(LifecycleState.INITIALIZING, (Object)null, false);
this.initInternal();
this.setStateInternal(LifecycleState.INITIALIZED, (Object)null, false);
} catch (Throwable var2) {
this.handleSubClassException(var2, "lifecycleBase.initFail", this.toString());
}
}
protected abstract void initInternal() throws LifecycleException;
public final synchronized void start() throws LifecycleException {
if (!LifecycleState.STARTING_PREP.equals(this.state) && !LifecycleState.STARTING.equals(this.state) && !LifecycleState.STARTED.equals(this.state)) {
if (this.state.equals(LifecycleState.NEW)) {
this.init();
} else if (this.state.equals(LifecycleState.FAILED)) {
this.stop();
} else if (!this.state.equals(LifecycleState.INITIALIZED) && !this.state.equals(LifecycleState.STOPPED)) {
this.invalidTransition("before_start");
}
try {
this.setStateInternal(LifecycleState.STARTING_PREP, (Object)null, false);
this.startInternal();
if (this.state.equals(LifecycleState.FAILED)) {
this.stop();
} else if (!this.state.equals(LifecycleState.STARTING)) {
this.invalidTransition("after_start");
} else {
this.setStateInternal(LifecycleState.STARTED, (Object)null, false);
}
} catch (Throwable var2) {
this.handleSubClassException(var2, "lifecycleBase.startFail", this.toString());
}
} else {
if (log.isDebugEnabled()) {
Exception e = new LifecycleException();
log.debug(sm.getString("lifecycleBase.alreadyStarted", new Object[]{this.toString()}), e);
} else if (log.isInfoEnabled()) {
log.info(sm.getString("lifecycleBase.alreadyStarted", new Object[]{this.toString()}));
}
}
}
protected abstract void startInternal() throws LifecycleException;
public final synchronized void stop() throws LifecycleException {
if (!LifecycleState.STOPPING_PREP.equals(this.state) && !LifecycleState.STOPPING.equals(this.state) && !LifecycleState.STOPPED.equals(this.state)) {
if (this.state.equals(LifecycleState.NEW)) {
this.state = LifecycleState.STOPPED;
} else {
if (!this.state.equals(LifecycleState.STARTED) && !this.state.equals(LifecycleState.FAILED)) {
this.invalidTransition("before_stop");
}
try {
if (this.state.equals(LifecycleState.FAILED)) {
this.fireLifecycleEvent("before_stop", (Object)null);
} else {
this.setStateInternal(LifecycleState.STOPPING_PREP, (Object)null, false);
}
this.stopInternal();
if (!this.state.equals(LifecycleState.STOPPING) && !this.state.equals(LifecycleState.FAILED)) {
this.invalidTransition("after_stop");
}
this.setStateInternal(LifecycleState.STOPPED, (Object)null, false);
} catch (Throwable var5) {
this.handleSubClassException(var5, "lifecycleBase.stopFail", this.toString());
} finally {
if (this instanceof SingleUse) {
this.setStateInternal(LifecycleState.STOPPED, (Object)null, false);
this.destroy();
}
}
}
} else {
if (log.isDebugEnabled()) {
Exception e = new LifecycleException();
log.debug(sm.getString("lifecycleBase.alreadyStopped", new Object[]{this.toString()}), e);
} else if (log.isInfoEnabled()) {
log.info(sm.getString("lifecycleBase.alreadyStopped", new Object[]{this.toString()}));
}
}
}
protected abstract void stopInternal() throws LifecycleException;
public final synchronized void destroy() throws LifecycleException {
if (LifecycleState.FAILED.equals(this.state)) {
try {
this.stop();
} catch (LifecycleException var3) {
log.warn(sm.getString("lifecycleBase.destroyStopFail", new Object[]{this.toString()}), var3);
}
}
if (!LifecycleState.DESTROYING.equals(this.state) && !LifecycleState.DESTROYED.equals(this.state)) {
if (!this.state.equals(LifecycleState.STOPPED) && !this.state.equals(LifecycleState.FAILED) && !this.state.equals(LifecycleState.NEW) && !this.state.equals(LifecycleState.INITIALIZED)) {
this.invalidTransition("before_destroy");
}
try {
this.setStateInternal(LifecycleState.DESTROYING, (Object)null, false);
this.destroyInternal();
this.setStateInternal(LifecycleState.DESTROYED, (Object)null, false);
} catch (Throwable var2) {
this.handleSubClassException(var2, "lifecycleBase.destroyFail", this.toString());
}
} else {
if (log.isDebugEnabled()) {
Exception e = new LifecycleException();
log.debug(sm.getString("lifecycleBase.alreadyDestroyed", new Object[]{this.toString()}), e);
} else if (log.isInfoEnabled() && !(this instanceof SingleUse)) {
log.info(sm.getString("lifecycleBase.alreadyDestroyed", new Object[]{this.toString()}));
}
}
}
protected abstract void destroyInternal() throws LifecycleException;
public LifecycleState getState() {
return this.state;
}
public String getStateName() {
return this.getState().toString();
}
protected synchronized void setState(LifecycleState state) throws LifecycleException {
this.setStateInternal(state, (Object)null, true);
}
protected synchronized void setState(LifecycleState state, Object data) throws LifecycleException {
this.setStateInternal(state, data, true);
}
private synchronized void setStateInternal(LifecycleState state, Object data, boolean check) throws LifecycleException {
if (log.isDebugEnabled()) {
log.debug(sm.getString("lifecycleBase.setState", new Object[]{this, state}));
}
if (check) {
if (state == null) {
this.invalidTransition("null");
return;
}
if (state != LifecycleState.FAILED && (this.state != LifecycleState.STARTING_PREP || state != LifecycleState.STARTING) && (this.state != LifecycleState.STOPPING_PREP || state != LifecycleState.STOPPING) && (this.state != LifecycleState.FAILED || state != LifecycleState.STOPPING)) {
this.invalidTransition(state.name());
}
}
this.state = state;
String lifecycleEvent = state.getLifecycleEvent();
if (lifecycleEvent != null) {
this.fireLifecycleEvent(lifecycleEvent, data);
}
}
private void invalidTransition(String type) throws LifecycleException {
String msg = sm.getString("lifecycleBase.invalidTransition", new Object[]{type, this.toString(), this.state});
throw new LifecycleException(msg);
}
private void handleSubClassException(Throwable t, String key, Object... args) throws LifecycleException {
ExceptionUtils.handleThrowable((Throwable)t);
this.setStateInternal(LifecycleState.FAILED, (Object)null, false);
String msg = sm.getString(key, args);
if (this.getThrowOnFailure()) {
if (!(t instanceof LifecycleException)) {
t = new LifecycleException(msg, (Throwable)t);
}
throw (LifecycleException)t;
} else {
log.error(msg, (Throwable)t);
}
}
}