Tomcat中有很多組件,Tomcat啓動的時候這些組件就會啓動,當Tomcat關閉的時候這些組件就會關閉.
實現Lifecycle接口的最賤可以觸發下面這些LifecycleEvent:START_EVENT, BEFORE_START_EVENT, AFTER_START_EVENT, STOP_EVENT, BEFORE_STOP_EVENT, AFTER_STOP_EVENT.
當實現Lifecycle接口的組件觸發上述的事件的時候,會調用註冊在實現Lifecycle接口組件中的監聽器LifecycleListener.
上述的過程其實和我們Tomcat中的Servlet的監聽器很類似.可以說就是一個事件監聽模型.
下面我們挨個介紹使用到的幾個接口:
1.Lifecycle 事件源,發佈事件給監聽器,表示具有生命週期的組件
2.LifecyceEvent 事件, 表示Lifecycle觸發的事件,觸發的事件會通知監聽該Lifecycle的LifecycleListener.
3.LifecycleListener 事件監聽器,監聽Lifecycle組件, 當Liferay組件觸發某事件的時候, LifecycleListener 就會收到Lifecycle發送過來的 LifecyceEvent
4.LifecycleSupport 負責Lifecycle組件的事件管理工作
簡單的來說就是Lifecycle相當於一個新聞訂閱中心,LifecycleEvent相當於消息,LifecycleListener相當於訂閱者.當我們訂閱新聞(監聽器註冊在Lifecycle組件中),新聞訂閱中心有新動態發佈的時候,會把消息發送給訂閱者(.LifecycleListener)最新的動態(LifecyceEvent)
1.Lifecycle
package weber.test.tomcat.lifecycle;
/**
* 實現該接口,表示該接口具有Lifecycle生命週期,可以觸發以下的事件
* 1.可以註冊監聽器,刪除監聽器
* 2.啓動調用start方法 停止調用stop方法
*
*/
public interface Lifecycle {
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 void addLifecycleListener(LifecycleListener listener);
public LifecycleListener[] findLifecycleListeners();
public void removeLifecycleListener(LifecycleListener listener);
public void start();
public void stop();
}
package weber.test.tomcat.lifecycle;
import java.util.EventObject;
/**
*
* Lifecycle組件促發事件發送LifecycleEvent給LifecycleListener
* Event包含事件信息,事件源等
*
*/
public final class LifecycleEvent extends EventObject {
private static final long serialVersionUID = 1L;
public LifecycleEvent(Lifecycle lifecycle, String type) {
this(lifecycle, type, null);
}
public LifecycleEvent(Lifecycle lifecycle, String type, Object data) {
super(lifecycle);
this.lifecycle = lifecycle;
this.type = type;
this.data = data;
}
private Object data = null;
private Lifecycle lifecycle = null;
private String type = null;
public Object getData() {
return (this.data);
}
public Lifecycle getLifecycle() {
return (this.lifecycle);
}
public String getType() {
return (this.type);
}
}
3.LifecycleListener
package weber.test.tomcat.lifecycle;
/**
*
* 註冊到Lifecycle組件的監聽器, 當Lifecycle組件觸發事件的時候,會調用lifecycleEvent方法
*/
public interface LifecycleListener {
public void lifecycleEvent(LifecycleEvent event);
}
4.LifecycleSupport
package weber.test.tomcat.lifecycle;
/**
*
* 該類實際用來管理Lifecycle的事件,包括事件監聽器的註冊和刪除,觸發事件
* 一般來說,我們直接在Lifecycle的實例中使用一個LifecycleSupport實例來實現這個效果.
* 詳細請看LifecycleComponent的代碼
*
*/
public final class LifecycleSupport {
public LifecycleSupport(Lifecycle lifecycle) {
super();
this.lifecycle = lifecycle;
}
private Lifecycle lifecycle = null;
private LifecycleListener listeners[] = new LifecycleListener[0];
public void addLifecycleListener(LifecycleListener listener) {
synchronized (listeners) {
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 LifecycleListener[] findLifecycleListeners() {
return listeners;
}
public void fireLifecycleEvent(String type, Object data) {
LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);
LifecycleListener interested[] = null;
synchronized (listeners) {
interested = (LifecycleListener[]) listeners.clone();
}
for (int i = 0; i < interested.length; i++)
interested[i].lifecycleEvent(event);
}
public void removeLifecycleListener(LifecycleListener listener) {
synchronized (listeners) {
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;
}
}
}
測試代碼
1.LifecycleComponent 實現Lifecycle的組件
package weber.test.tomcat.lifecycle;
/**
*
* 測試使用的實現Lifecycle的組件
*
*/
public class LifecycleComponent implements Lifecycle {
//相當於組件的事件監聽管理器
private LifecycleSupport lifecycle = new LifecycleSupport(this);
@Override
public void addLifecycleListener(LifecycleListener listener) {
lifecycle.addLifecycleListener(listener);
}
@Override
public LifecycleListener[] findLifecycleListeners() {
return lifecycle.findLifecycleListeners();
}
@Override
public void removeLifecycleListener(LifecycleListener listener) {
lifecycle.removeLifecycleListener(listener);
}
@Override
public void start() {
//啓動前觸發啓動前的事件
lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
System.out.println("LifecycleComponent start");
lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
}
@Override
public void stop() {
lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);
lifecycle.fireLifecycleEvent(STOP_EVENT, null);
System.out.println("LifecycleComponent stop");
lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
}
}
2,SimpleLifecycleListener 實現LifecycleListener接口的事件監聽器
package weber.test.tomcat.lifecycle;
/**
*
* 測試使用的簡單事件監聽器
* 我們將使用它註冊到我們的測試Lifecycle組件中
*
*/
public class SimpleLifecycleListener implements LifecycleListener {
public void lifecycleEvent(LifecycleEvent event) {
Lifecycle lifecycle = event.getLifecycle();
System.out.println("SimpleLifecycleListener's event " + event.getType().toString());
if (Lifecycle.START_EVENT.equals(event.getType())) {
System.out.println("Starting .");
} else if (Lifecycle.STOP_EVENT.equals(event.getType())) {
System.out.println("Stopping.");
}
}
}3.測試main類LifecycleTest
package weber.test.tomcat.lifecycle;
/**
*
* 測試mian
*
*/
public class LifecycleTest {
public static void main(String[] args) throws InterruptedException {
//new 一個組件實例
LifecycleComponent compoment = new LifecycleComponent();
//給組件註冊事件監聽器
compoment.addLifecycleListener(new SimpleLifecycleListener());
//組件調用Lifecycle的啓動函數
compoment.start();
Thread.sleep(1000);
//組件調用Lifecycle的停止函數
compoment.stop();
}
}
運行結果:
SimpleLifecycleListener's event before_start
LifecycleComponent start
SimpleLifecycleListener's event after_start
SimpleLifecycleListener's event before_stop
SimpleLifecycleListener's event stop
Stopping.
LifecycleComponent stop
SimpleLifecycleListener's event after_stop