`
uule
  • 浏览: 6348680 次
  • 性别: Icon_minigender_1
  • 来自: 一片神奇的土地
社区版块
存档分类
最新评论

Lifecycle-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

 

 

 

 

分享到:
评论

相关推荐

    apache-tomcat-9.0.8-src源码资源

    5. **部署与生命周期管理**: Tomcat提供自动部署和管理Web应用的功能,这涉及到`StandardContext`和`LifeCycle`接口的实现。 6. **安全管理**: Tomcat的安全特性包括用户认证、角色授权等,这在`org.apache....

    tomcat 生命周期,和事件管理—— lifeCycle & event

    在描述中提到的InstanceSupport.edx文件可能是一个教学资源,可能包含了关于Tomcat生命周期和事件管理的详细讲解和实例。通常,这种类型的文件可能是教育平台如EdX上的课程资料,用于辅助学习者理解相关概念。 了解...

    apache-tomcat-9.0.8-src可直接导入eclipse的源码

    4. **Lifecycle**:Tomcat的组件遵循生命周期管理,包括初始化、启动、停止和销毁等阶段。 5. **Naming and Directory Interface (JNDI)**:Tomcat使用JNDI提供命名和目录服务,用于查找和绑定资源,如数据源、邮件...

    apache-tomcat-6.0.10

    2. Jasper:Jasper负责JSP的编译和执行,将JSP转换为Servlet并管理其生命周期。 3. Coyote:提供了HTTP/1.1协议的支持,处理来自客户端的HTTP请求,并将响应返回给客户端。 4. JMX Remote Lifecycle Listener:这个...

    apache-tomcat-9.0.38.zip

    - **LifecycleListeners**:生命周期监听器,可以监听Tomcat的启动、停止等事件。 2. **Tomcat 9.0.38的更新**: 每个新版本通常会包含性能优化、安全修复和新功能。9.0.38版本可能包括对之前版本的bug修复,增强...

    apache-tomcat-8.5.50-src.zip

    组件的生命周期管理 用Lifecycle管理启动、停止、关闭 Lifecycle接口预览 几个核心方法 Server中的init方法示例 为啥StandardServer没有init方法 LifecycleBase中的init与initInternal方法 为什么这么设计...

    btm-tomcat55等所需jar包最全

    2. **btm-tomcat55-lifecycle-2.1.4**:这个jar包是专门为Tomcat5.5定制的BTM生命周期模块,它允许BTM与Tomcat的启动和停止过程无缝集成,确保在Tomcat启动时自动配置事务管理器,并在停止时清理资源。 3. **H2 ...

    apache-tomcat-6.0.33-src tomcat6.0.33源代码

    8. **生命周期管理**:Tomcat组件遵循一种称为"生命周期"的概念,使得它们可以在启动、运行和停止时执行特定的步骤。`Lifecycle`接口和`LifecycleListener`接口是这一概念的核心。 9. **线程模型**:Tomcat使用工作...

    apache-tomcat-8.5.100-src Tomcat源码解析

    4. `Lifecycle`和`Container`接口:这两个接口定义了Tomcat组件的生命周期管理和容器结构。所有Tomcat组件都遵循这些接口定义的状态转换和嵌套容器模型。 5. `Server.xml`配置文件:这是Tomcat最重要的配置文件,...

    apache-tomcat-8.5.65-src.zip

    3. **生命周期管理**:Tomcat采用Java的生命周期接口(Lifecycle Interface)来管理其组件,如`LifecycleListener`监听器,确保了组件在启动、停止、初始化和销毁时的正确操作。 4. **服务器配置**:在`conf`目录下...

    apache-tomcat-7.0.99-src.zip

    3. **生命周期管理**:在`catalina`包中,可以看到`Lifecycle`接口和相关的生命周期管理类。每个Tomcat组件都有其特定的生命周期阶段,如初始化、启动、停止和销毁。 4. **容器概念**:Tomcat使用容器的概念来组织...

    Tomcat源码 学习java很好的东东 apache-tomcat-6.0.26-src

    2. **生命周期管理**:在源码中,可以看到Tomcat如何通过生命周期接口(Lifecycle interface)和生命周期事件(LifecycleEvent)来管理各个组件的启动、停止和暂停等状态。了解这些,有助于我们掌握如何在运行时动态...

    apache-tomcat-6.0.18源码

    5. **生命周期管理**:Tomcat使用Java的生命周期接口(Lifecycle)来管理和控制其组件的状态。每个组件都有若干个状态(如 初始化、运行、暂停、停止、销毁),并且可以注册监听器来响应这些状态变化。 6. **线程...

    02-Tomcat源码解读1

    生命周期(Lifecycle)是Tomcat设计中的一个重要概念,它通过`Lifecycle`接口统一管理各个组件的启动、停止和关闭操作。此外,`MBeanRegistration`接口用于实现JMX(Java Management Extensions)功能,使得我们可以...

    how-tomcat-works中文版

    第6章:生命周期(Lifecycle) 容器和其组件都有各自的生命周期,包括初始化、启动、停止和销毁等阶段。本章将探讨这些阶段的详细过程,以及如何通过接口和事件来控制这些阶段。 第7章:Logger 日志系统在Tomcat中...

    tomcat-8.5.40版本源码压缩包

    - Tomcat使用了Java的生命周期接口(Lifecycle interface)来管理各个组件的状态,如启动、停止、暂停和恢复。 4. **容器概念**: - **Engine**:顶级容器,管理多个Host。 - **Host**:对应于域名,管理多个...

Global site tag (gtag.js) - Google Analytics