涉及到的类或接口:Lifecycle,LifecycleListener,LifecycleEvent,LifecycleSupport。
Lifecycle接口:
public static final String INIT_EVENT = "init";
public static final String START_EVENT = "start";
public static final String BEFORE_START_EVENT = "before_start";
public static final String AFTER_START_EVENT = "after_start";
public static final String STOP_EVENT = "stop";
public static final String BEFORE_STOP_EVENT = "before_stop";
public static final String AFTER_STOP_EVENT = "after_stop";
public static final String DESTROY_EVENT = "destroy";
public static final String PERIODIC_EVENT = "periodic";
public void addLifecycleListener(LifecycleListener listener);
public LifecycleListener[] findLifecycleListeners();
public void removeLifecycleListener(LifecycleListener listener);
public void start() throws LifecycleException;
public void stop() throws LifecycleException;
很明显,其中定义了很多状态常量。addLifecycleListener是为了向这个组件(一般组件都要实现这个接口,他们都有生命周期)注册监听器LifecycleListener。
findLifecycleListeners是为了找出已经向这个组件注册了的监听器。很容易想到removeLifecycleListener这个函数的功能。其实很多组件中的start()都是从这里继承的。
LifecycleListener:
public void lifecycleEvent(LifecycleEvent event);
它就只有这个方法。这就是当event被触发了之后listener要执行的动作。
LifecycleEvent:
private Object data = null;
private Lifecycle lifecycle = null;
private String type = null;
type就是组件的状态标识
LifecycleSupport:这是一个工具类。里面维护了一个组件的状态和一个组件。
public LifecycleSupport(Lifecycle lifecycle) {
super();
this.lifecycle = lifecycle;
}
public void addLifecycleListener(LifecycleListener listener) {
synchronized (listenersLock) {
LifecycleListener results[] =
new LifecycleListener[listeners.length + 1];
for (int i = 0; i < listeners.length; i++)
results[i] = listeners[i];
results[listeners.length] = listener;
listeners = results;
}
}
public void fireLifecycleEvent(String type, Object data) {
if (Lifecycle.INIT_EVENT.equals(type)) {
state = "INITIALIZED";
} else if (Lifecycle.BEFORE_START_EVENT.equals(type)) {
state = "STARTING_PREP";
} else if (Lifecycle.START_EVENT.equals(type)) {
state = "STARTING";
} else if (Lifecycle.AFTER_START_EVENT.equals(type)) {
state = "STARTED";
} else if (Lifecycle.BEFORE_STOP_EVENT.equals(type)) {
state = "STOPPING_PREP";
} else if (Lifecycle.STOP_EVENT.equals(type)) {
state = "STOPPING";
} else if (Lifecycle.AFTER_STOP_EVENT.equals(type)) {
state = "STOPPED";
} else if (Lifecycle.DESTROY_EVENT.equals(type)) {
state = "DESTROYED";
}
LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);
LifecycleListener interested[] = listeners;
for (int i = 0; i < interested.length; i++)
interested[i].lifecycleEvent(event);
}
public void removeLifecycleListener(LifecycleListener listener) {
synchronized (listenersLock) {
int n = -1;
for (int i = 0; i < listeners.length; i++) {
if (listeners[i] == 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[i];
}
listeners = results;
}
}
代码不多说,很简单吧。
下面来整体的分析下执行过程:(这里采用connector这个组件来分析)
因为connector太复杂了,大部分我也没怎么看懂,先来看看涉及到lifecycle的部分吧。
在connector中的start()方法中(connector也是个组件,实现了lifecycle接口,所以会有start(),基本上所有的组件都应该有这个方法,所以把它放入lifecycle接口中)。
lifecycle.fireLifecycleEvent(START_EVENT, null);
在stop()方法中调用:
lifecycle.fireLifecycleEvent(STOP_EVENT, null);
其中lifecycle是在组件connector中维护的一个LifecycleSupport工具类的一个实例。在connector的start状态给所有监听者一个通知,然后每个监听者都会去执行他们的
lifecycleEvent方法。
这里很明显用到的设计模式是观察者模式。