学步园

涉及到的类或接口：Lifecycle，LifecycleListener，LifecycleEvent，LifecycleSupport。

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 static final String PERIODIC_EVENT = "periodic";

    public void addLifecycleListener(LifecycleListener listener);


    public LifecycleListener[] findLifecycleListeners();

    public void removeLifecycleListener(LifecycleListener listener);

    public void start() throws LifecycleException;

    public void stop() throws LifecycleException;

很明显，其中定义了很多状态常量。addLifecycleListener是为了向这个组件（一般组件都要实现这个接口，他们都有生命周期）注册监听器LifecycleListener。

findLifecycleListeners是为了找出已经向这个组件注册了的监听器。很容易想到removeLifecycleListener这个函数的功能。其实很多组件中的start()都是从这里继承的。

LifecycleListener：

public void lifecycleEvent(LifecycleEvent event);

它就只有这个方法。这就是当event被触发了之后listener要执行的动作。

LifecycleEvent：

private Object data = null;
private Lifecycle lifecycle = null;
private String type = null;

type就是组件的状态标识

LifecycleSupport：这是一个工具类。里面维护了一个组件的状态和一个组件。

public LifecycleSupport(Lifecycle lifecycle) {

        super();
        this.lifecycle = lifecycle;

    }

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

        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";
        }
        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;
        }

    }

代码不多说，很简单吧。

下面来整体的分析下执行过程：（这里采用connector这个组件来分析）

因为connector太复杂了，大部分我也没怎么看懂，先来看看涉及到lifecycle的部分吧。

在connector中的start()方法中(connector也是个组件，实现了lifecycle接口，所以会有start()，基本上所有的组件都应该有这个方法，所以把它放入lifecycle接口中)。

lifecycle.fireLifecycleEvent(START_EVENT, null);

在stop()方法中调用：

lifecycle.fireLifecycleEvent(STOP_EVENT, null);

其中lifecycle是在组件connector中维护的一个LifecycleSupport工具类的一个实例。在connector的start状态给所有监听者一个通知，然后每个监听者都会去执行他们的

lifecycleEvent方法。

这里很明显用到的设计模式是观察者模式。