Tomcat组件的生命周期Lifecycle

最新推荐文章于 2021-02-16 05:44:17 发布

yhjyumi

最新推荐文章于 2021-02-16 05:44:17 发布

阅读量634

点赞数

分类专栏： server

本文链接：https://blog.csdn.net/yhjyumi/article/details/47375169

版权

server 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

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();

}

2.LifecyceEvent

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

yhjyumi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Tomcat组件的生命周期Lifecycle

Tomcat中有很多组件,Tomcat启动的时候这些组件就会启动,当Tomcat关闭的时候这些组件就会关闭.实现Lifecycle接口的最贱可以触发下面这些LifecycleEvent:START_EVENT, BEFORE_START_EVENT, AFTER_START_EVENT, STOP_EVENT, BEFORE_STOP_EVENT, AFTER_STOP_EVENT.当
复制链接

扫一扫