Lifecycle-Tomcat生命周期

uule

浏览: 6302873 次
性别:
来自: 一片神奇的土地

最近访客更多访客>>

wangenbao1

hyjqdy

逆光下的轮廓

taominghua

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

tomcat源码学习
源码学习

1 概述

Catalina包括很多组件，当catalina启动的时候，也需要启动这些组件，当关闭catalina的时候同时也需要关闭这些组件。Tomcat通过事件机制来实现这种控制，所有的组件都实现org.apache.catalina.Lifecycle接口。

例如，当container关闭时，它必须调用已经载入的servlet的destroy方法。tomcat中的实现机制是通过实现org.apache.catalina.Lifecycle接口来管理。

实现了org.apache.catalina.Lifecycle接口的组件会触发下面的事件：

BEFORE_START_EVENT；

START_EVENT；

AFTER_START_EVENT；

BEFORE_STOP_EVENT；

STOP_EVENT；

AFTER_STOP_EVENT。

当组件启动是会触发前三个事件（BEFORE_START_EVENT，START_EVENT，AFTER_START_EVENT），关闭组件时会触发后三个事件（BEFORE_STOP_EVENT，STOP_EVENT，AFTER_STOP_EVENT）。而相应的监听器由org.apache.catalina.LifecycleListener接口表示。

本章将讨论三种类型，Lifecycle接口、LifecycleListener接口、LifecycleEvent类、LifecycleSupport类。

2 Lifecycle接口

catalina在设计上允许一个组件包含其他组件，如container中可以包含loader，manger等组件。

父组件负责启动/关闭其包含的子组件。所有的组件都可以通过其父组件来启动/关闭，这种单一启动/关闭机制是通过Lifecycle接口实现的。Lifecycle接口定义如下：

package org.apache.catalina; 

public interface 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 void addLifecycleListener(LifecycleListener listener); 
	
	public LifecycleListener[] findLifecycleListeners(); 
	
	public void removeLifecycleListener(LifecycleListener listener); 
	
	public void start() throws LifecycleException; 
	
	public void stop() throws LifecycleException; 
}

其中，最重要的方法时start和stop方法。父组件通过这两个方法来启动/关闭该组件。addLifecycleListener，findLifecycleListeners，removeLifecycleListener三个方法用于向组件注册/查找/删除监听器。当事件发生时，会触发监听器。接口中还定义了相关事件。

3. LifecycleListener接口

接口定义如下：

//当监听的事件发生时，触发LifecycleListener接口的lifecycleEvent方法
package org.apache.catalina;

public interface LifecycleListener {
  
    //具体实现放在各组件对应的LifecycleListener中
    public void lifecycleEvent(LifecycleEvent event);
}

其中，当监听的事件发生时，触发lifecycleEvent方法。

4. LifecycleEvent类

org.apache.catalina.LifecycleEvent类表示生命周期中的某个事件。定义如下：

//LifecycleEvent类表示生命周期中的某个事件
package org.apache.catalina;

public final class LifecycleEvent {

	//type即为各状态init、start。。。
    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);
    }

}

5 LifecycleSupport类

实现了Lifecycle接口的组件可以向监听器注册感兴趣的事件，catalina提供一个工具类来管理对组件注册的监听器，org.apache.catalina.util.LifecycleSupport。代码如下：

LifecycleSupport类中用数组类型的变量listeners存储了所有监听器。当添加一个新的监听器时，是创建一个新数组，存储全部的监听器。删除一个监听器的时候，也是返回一个新的数组对象。

fireLifecycleEvent方法会触发已经注册的各个监听器。

实现了Lifecycle接口的组件可以使用LifecycleSupport类，对监听器进行添加、删除、触发等操作。

//catalina提供一个工具类来管理对组件注册的监听器LifecycleSupport，实现了Lifecycle接口的组件可以向监听器注册感兴趣的事件，
/**
* LifecycleSupport类中用数组类型的变量listeners存储了所有监听器。
*  当添加一个新的监听器时，是创建一个新数组，存储全部的监听器。删除一个监听器的时候，也是返回一个新的数组对象。
*         fireLifecycleEvent方法会触发已经注册的各个监听器。
*/

package org.apache.catalina.util;

import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleEvent;
import org.apache.catalina.LifecycleListener;

/* catalina提供一个工具类来管理对组件注册的监听器LifecycleSupport，实现了Lifecycle接口的组件可以向监听器注册感兴趣的事件
* 各步骤类使用LifecycleSupport  处理，如StandardServer类:
* 构造函数调用addLifecycleListener添加listener，
* 初始化时调用fireLifecycleEvent ，如lifecycle.fireLifecycleEvent(INIT_EVENT, null);其他操作类似 
*     
* private LifecycleSupport lifecycle = new LifecycleSupport(this); 
*/

/*fireLifecycleEvent(String type, Object data) 中初始化LifecycleEvent，同时触发
* 各监听器LifecycleListener 调用interested[i].lifecycleEvent(event); 
* type为 类型init/before_start/start/after_start/stop等
* 
* lifecycle 参数为上方LifecycleSupport中对象this
* LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);  
*/
public final class LifecycleSupport {


    public LifecycleSupport(Lifecycle lifecycle) {
        super();
        this.lifecycle = lifecycle;
    }

    private Lifecycle lifecycle = null;
	
    private LifecycleListener listeners[] = new LifecycleListener[0];
    
    private final Object listenersLock = new Object(); // Lock object for changes to listeners
   
    private String state = "NEW";
    

    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 LifecycleListener[] findLifecycleListeners() {
        return listeners;
    }

	
    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";
        }
		//通过type判断哪个状态
        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;
        }

    }

    public String getState() {
        return state;
    }
}

public class MyLifecycle1Listener implements LifecycleListener {
 
	@Override
	public void lifecycleEvent(LifecycleEvent event) {
		MyLifecycle1 myLifecycle1 = (MyLifecycle1) event.getLifecycle();
//		System.out.println(myLifecycle1);
		if (event.getType().equals(Lifecycle.BEFORE_INIT_EVENT)) { 
			beforeInit();
		} else if (event.getType().equals(Lifecycle.AFTER_INIT_EVENT)) {
		} else if (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
		} else if (event.getType().equals(Lifecycle.START_EVENT)) {
		} else if (event.getType().equals(Lifecycle.AFTER_START_EVENT)) {
		} else if (event.getType().equals(Lifecycle.BEFORE_STOP_EVENT)) {
		} else if (event.getType().equals(Lifecycle.STOP_EVENT)) {
		} else if (event.getType().equals(Lifecycle.AFTER_STOP_EVENT)) {
		} else if (event.getType().equals(Lifecycle.BEFORE_DESTROY_EVENT)) {
		} else if (event.getType().equals(Lifecycle.AFTER_DESTROY_EVENT)) {
		}
		System.out.println("trigger event : " + event.getType());
	}
 
	protected synchronized void beforeInit() {
 
	}
 
}

具体组件使用：

Catalina包括很多组件，当catalina启动的时候，也需要启动这些组件，当关闭catalina的时候同时也需要关闭这些组件。Tomcat通过事件机制来实现这种控制，所有的组件都实现org.apache.catalina.Lifecycle接口。

//注意组件实现了Lifecycle接口
public final class StandardServer
				implements Lifecycle  {
			
	//catalina提供一个工具类来管理对组件注册的监听器LifecycleSupport，实现了Lifecycle接口的组件可以向监听器注册感兴趣的事件，  		
	private LifecycleSupport lifecycle = new LifecycleSupport(this);
	
	
	private NamingContextListener namingContextListener = null;
	
	private Service services[] = new Service[0];
	
	/**
	* 构造方法中添加对应的监听器LifecycleListener
	*/
	public StandardServer() {

        super();
        ServerFactory.setServer(this);

        globalNamingResources = new NamingResources();
        globalNamingResources.setContainer(this);

        if (isUseNaming()) {
            if (namingContextListener == null) {
                namingContextListener = new NamingContextListener();
				
                addLifecycleListener(namingContextListener);
            }
        }

    }
	
	//LifecycleSupport工具类添加对应的监听器LifecycleListener
	
	/**
	* LifecycleSupport将该StandardServer对应的监听器NamingContextListener放入其内的LifecycleListener listeners[]数组中
	*
	*  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 addLifecycleListener(LifecycleListener listener) {

        lifecycle.addLifecycleListener(listener);

    }
	
	
	//组件初始化
	public void initialize()    {
        if (initialized) {
                log.info(sm.getString("standardServer.initialize.initialized"));
            return;
        }
        lifecycle.fireLifecycleEvent(INIT_EVENT, null);
        initialized = true;

		......
		
        // Initialize our defined Services
        for (int i = 0; i < services.length; i++) {
            services[i].initialize();
        }
    }
    
			
	//组件启动	
	public void start() throws LifecycleException {

        if (started) {
            log.debug(sm.getString("standardServer.start.started"));
            return;
        }

        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);

        lifecycle.fireLifecycleEvent(START_EVENT, null);
        started = true;

        // 启动子组件Services		
        synchronized (services) {
            for (int i = 0; i < services.length; i++) {
                if (services[i] instanceof Lifecycle)
                    ((Lifecycle) services[i]).start();
            }
        }

        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);

    }

	
	//组件关闭
	public void stop() throws LifecycleException {

        // Validate and update our current component state
        if (!started)
            return;

        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);

        lifecycle.fireLifecycleEvent(STOP_EVENT, null);
        started = false;

        // Stop our defined Services
        for (int i = 0; i < services.length; i++) {
            if (services[i] instanceof Lifecycle)
                ((Lifecycle) services[i]).stop();
        }
		
        lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);

        stopAwait();

    }
	
	
	/**
	* 添加子组件
	*/
	public void addService(Service service) {

        service.setServer(this);

        synchronized (services) {
            Service results[] = new Service[services.length + 1];
            System.arraycopy(services, 0, results, 0, services.length);
            results[services.length] = service;
            services = results;

            if (initialized) {
                try {
                    service.initialize();
                } catch (LifecycleException e) {
                    log.error(e);
                }
            }

            if (started && (service instanceof Lifecycle)) {
                try {
                    ((Lifecycle) service).start();
                } catch (LifecycleException e) {
                    ;
                }
            }

            // Report this property change to interested listeners
            support.firePropertyChange("service", null, service);
        }

    }
	
	
	。。。
}

public class NamingContextListener
		implements LifecycleListener {
		
			
	public void lifecycleEvent(LifecycleEvent event) {
		//具体实现方法
		...
		
		if (event.getType() == Lifecycle.START_EVENT) {            

        } else if (event.getType() == Lifecycle.STOP_EVENT) {           

        }
	}	
		
}

参考：《深入剖析Tomcat 》第6章生命周期（Lifecycle）

tomcat 7 源码分析-8 生命周期lifecycle和监听listener

How Tomcat Works学习笔记<六>

Tomcat自定义LifecycleListener，如何监听StandardContext

分享到：