Tomcat学习笔记(五)

　　生命周期事件

　　Catalina包含有很多组件。当Catalina启动时，这些组件也会启动，同样，当Catalina关闭时，这些组件也随之关闭，通过实现org.apache.catalina.Lifecycle接口，可以达到统一启动/关闭这些组件的效果。

实现Lifecycle接口的组件可以触发一个或多个下面的事件：BEFORE_START_EVENT、START_EVENT、AFTER_START_EVENT、BEFORE_STOP_EVENT、STOP_EVENT、AFTER_STOP_EVENT 。当组件启动时，正常会触发前3个事件，而关闭组件时，会触发后3个事件。如果Catalina组件可以触发事件，那么需要编写相应的事件监听器对这些事件进行响应。事件监听器是org.apache.catalina.LifecycleListener接口实例。

tomcat内部架构各个核心组件的包含关系。例如server包含service,service包含container，一层层包含。而这种结构类似数据结构中的树形结构，对于tomcat的启动也是鉴于此，可以通过父容器启动子容器，这样可以达到只要启动根容器，从而启动所有的组件，同时便于管理达到统一启动、停止、关闭的效果。

生命周期采用是观察者模式(监听事件)。

简单看一下tomcat的设计源码

事件对象LifecycleEvent

public final class LifecycleEvent extends EventObject {

    private static final long serialVersionUID = 1L;

    // ----------------------------------------------------------- Constructors

    /**

     * Construct a new LifecycleEvent with the specified parameters.

     *

     * @param lifecycle Component on which this event occurred

     * @param type Event type (required)

     * @param data Event data (if any)

     */

    public LifecycleEvent(Lifecycle lifecycle, String type, Object data) {

        super(lifecycle);

        this.type = type;

        this.data = data;

    }

    // ----------------------------------------------------- Instance Variables

    /**

     * The event data associated with this event.

     */

    private Object data = null;

    /**

     * The event type this instance represents.

     */

    private String type = null;

    // ------------------------------------------------------------- Properties

    /**

     * Return the event data of this event.

     */

    public Object getData() {

        return (this.data);

    }

    /**

     * Return the Lifecycle on which this event occurred.

     */

    public Lifecycle getLifecycle() {

        return (Lifecycle) getSource();

    }

    /**

     * Return the event type of this event.

     */

    public String getType() {

        return (this.type);

    }

}

事件监听接口LifecycleListener

public interface LifecycleListener {

    /**

     * Acknowledge the occurrence of the specified event.

     *

     * @param event LifecycleEvent that has occurred

     */

    public void lifecycleEvent(LifecycleEvent event);

}

事件监听实现类JasperListener

public void lifecycleEvent(LifecycleEvent event) {

        if (Lifecycle.BEFORE_INIT_EVENT.equals(event.getType())) {

            try {

                // Set JSP factory

                Class.forName("org.apache.jasper.compiler.JspRuntimeContext",

                              true,

                              this.getClass().getClassLoader());

            } catch (Throwable t) {

                ExceptionUtils.handleThrowable(t);

                // Should not occur, obviously

                log.warn("Couldn't initialize Jasper", t);

            }

            // Another possibility is to do directly:

            // JspFactory.setDefaultFactory(new JspFactoryImpl());

        }

    }

事件监听类LifecycleSupport

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) {

        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;

        }

    }

事件源 ServerStandard@startInternal()

//触发事件

protected void startInternal() throws LifecycleException {

        fireLifecycleEvent(CONFIGURE_START_EVENT, null);

        setState(LifecycleState.STARTING);

        globalNamingResources.start();

        // Start our defined Services

        synchronized (services) {

            for (int i = 0; i < services.length; i++) {

                services[i].start();

            }

        }

    }

下面写了一个简单观察者模式的例子，便于理解。

import java.util.ArrayList;

import java.util.List;

class MacBookPro{

    public List<ITClient> clients = new ArrayList<ITClient>();

    public void addClientListener(ITClient client){

        clients.add(client);

    }

    public void notifyClient(String info){

        //通知所有放入监听者

        clients.forEach(x->x.receiveInfo(info));

    }

}

class ITClient{

    private String name;

    public ITClient(String name)

    {

        this.name = name;

    }

    public void receiveInfo(String info){

        System.out.println(this.name+" :: "+info);

    }

}

public class StateTest

{

    public static void main(String[] args)

    {

        MacBookPro mbp = new MacBookPro();

        ITClient c1 = new ITClient("员工1");

        ITClient c2 = new ITClient("员工2");

        ITClient c3 = new ITClient("员工3");

        mbp.addClientListener(c1);

        mbp.addClientListener(c2);

        mbp.addClientListener(c3);

        System.out.println("促销活动开始了");

        mbp.notifyClient("京东618大减价");

    }

}

结果:

促销活动开始了

员工1 :: 京东618大减价

员工2 :: 京东618大减价

员工3 :: 京东618大减价

巴特西

Tomcat学习笔记(五)

最新文章

热门文章