Overview | Package | Class | Tree | Deprecated | Index | Help
| Apache Tomcat 7.0.29
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.catalina.util
Class LifecycleBase

    java.lang.Object
      org.apache.catalina.util.LifecycleBase

All Implemented Interfaces:
  Lifecycle

Direct Known Subclasses:
  LifecycleMBeanBase, SimpleTcpCluster, StandardPipeline, StoreBase

    public abstract class LifecycleBase

extends Object
implements Lifecycle

Base implementation of the `Lifecycle` interface that implements the state transition rules for `Lifecycle.start()` and `Lifecycle.stop()`

Field Summary

Fields inherited from interface org.apache.catalina.Lifecycle
`AFTER_DESTROY_EVENT, AFTER_INIT_EVENT, AFTER_START_EVENT, AFTER_STOP_EVENT, BEFORE_DESTROY_EVENT, BEFORE_INIT_EVENT, BEFORE_START_EVENT, BEFORE_STOP_EVENT, CONFIGURE_START_EVENT, CONFIGURE_STOP_EVENT, PERIODIC_EVENT, START_EVENT, STOP_EVENT`

Constructor Summary
`LifecycleBase()`

Method Summary
`void` | `addLifecycleListener(LifecycleListener listener)` Add a LifecycleEvent listener to this component.
`void` | `destroy()` Prepare to discard the object.
`protected abstract void` | `destroyInternal()`
`LifecycleListener[]` | `findLifecycleListeners()` Get the life cycle listeners associated with this life cycle.
`protected void` | `fireLifecycleEvent(String type, Object data)` Allow sub classes to fire `Lifecycle` events.
`LifecycleState` | `getState()` Obtain the current state of the source component.
`String` | `getStateName()` Obtain a textual representation of the current component state.
`void` | `init()` Prepare the component for starting.
`protected abstract void` | `initInternal()`
`void` | `removeLifecycleListener(LifecycleListener listener)` Remove a LifecycleEvent listener from this component.
`protected void` | `setState(LifecycleState state)` Provides a mechanism for sub-classes to update the component state.
`protected void` | `setState(LifecycleState state, Object data)` Provides a mechanism for sub-classes to update the component state.
`void` | `start()` Prepare for the beginning of active use of the public methods other than property getters/setters and life cycle methods of this component.
`protected abstract void` | `startInternal()` Sub-classes must ensure that the state is changed to `LifecycleState.STARTING` during the execution of this method.
`void` | `stop()` Gracefully terminate the active use of the public methods other than property getters/setters and life cycle methods of this component.
`protected abstract void` | `stopInternal()` Sub-classes must ensure that the state is changed to `LifecycleState.STOPPING` during the execution of this method.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### LifecycleBase

    public LifecycleBase()

Method Detail

### addLifecycleListener

    public void addLifecycleListener(LifecycleListener listener)

  Add a LifecycleEvent listener to this component.

  Specified by:
    `addLifecycleListener` in interface `Lifecycle`
  Parameters:
    `listener` - The listener to add

### findLifecycleListeners

    public LifecycleListener[] findLifecycleListeners()

  Get the life cycle listeners associated with this life cycle. If this component has no listeners registered, a zero-length array is returned.

  Specified by:
    `findLifecycleListeners` in interface `Lifecycle`

### removeLifecycleListener

    public void removeLifecycleListener(LifecycleListener listener)

  Remove a LifecycleEvent listener from this component.

  Specified by:
    `removeLifecycleListener` in interface `Lifecycle`
  Parameters:
    `listener` - The listener to remove

### fireLifecycleEvent

    protected void fireLifecycleEvent(String type,
                                      Object data)

  Allow sub classes to fire `Lifecycle` events.

  Parameters:
    `type` - Event type
    `data` - Data associated with event.

### init

    public final void init()
                    throws LifecycleException

  Description copied from interface: `Lifecycle`
  Prepare the component for starting. This method should perform any initialization required post object creation. The following `LifecycleEvent`s will be fired in the following order:
  1. INIT_EVENT: On the successful completion of component initialization.

  Specified by:
    `init` in interface `Lifecycle`
  Throws:
    `LifecycleException` - if this component detects a fatal error that prevents this component from being used

### initInternal

    protected abstract void initInternal()
                                  throws LifecycleException

  Throws:
    `LifecycleException`

### start

    public final void start()
                     throws LifecycleException

  Prepare for the beginning of active use of the public methods other than property getters/setters and life cycle methods of this component. This method should be called before any of the public methods other than property getters/setters and life cycle methods of this component are utilized. The following `LifecycleEvent`s will be fired in the following order:
  1. BEFORE_START_EVENT: At the beginning of the method. It is as this point the state transitions to `LifecycleState.STARTING_PREP`.
  2. START_EVENT: During the method once it is safe to call start() for any child components. It is at this point that the state transitions to `LifecycleState.STARTING` and that the public methods other than property getters/setters and life cycle methods may be used.
  3. AFTER_START_EVENT: At the end of the method, immediately before it returns. It is at this point that the state transitions to `LifecycleState.STARTED`.

  Specified by:
    `start` in interface `Lifecycle`
  Throws:
    `LifecycleException` - if this component detects a fatal error that prevents this component from being used

### startInternal

    protected abstract void startInternal()
                                   throws LifecycleException

  Sub-classes must ensure that the state is changed to `LifecycleState.STARTING` during the execution of this method. Changing state will trigger the `Lifecycle.START_EVENT` event. If a component fails to start it may either throw a `LifecycleException` which will cause it's parent to fail to start or it can place itself in the error state in which case `stop()` will be called on the failed component but the parent component will continue to start normally.

  Throws:
    `LifecycleException`

### stop

    public final void stop()
                    throws LifecycleException

  Gracefully terminate the active use of the public methods other than property getters/setters and life cycle methods of this component. Once the STOP_EVENT is fired, the public methods other than property getters/setters and life cycle methods should not be used. The following `LifecycleEvent`s will be fired in the following order:
  1. BEFORE_STOP_EVENT: At the beginning of the method. It is at this point that the state transitions to `LifecycleState.STOPPING_PREP`.
  2. STOP_EVENT: During the method once it is safe to call stop() for any child components. It is at this point that the state transitions to `LifecycleState.STOPPING` and that the public methods other than property getters/setters and life cycle methods may no longer be used.
  3. AFTER_STOP_EVENT: At the end of the method, immediately before it returns. It is at this point that the state transitions to `LifecycleState.STOPPED`.
  Note that if transitioning from `LifecycleState.FAILED` then the three events above will be fired but the component will transition directly from `LifecycleState.FAILED` to `LifecycleState.STOPPING`, bypassing `LifecycleState.STOPPING_PREP`

  Specified by:
    `stop` in interface `Lifecycle`
  Throws:
    `LifecycleException` - if this component detects a fatal error that needs to be reported

### stopInternal

    protected abstract void stopInternal()
                                  throws LifecycleException

  Sub-classes must ensure that the state is changed to `LifecycleState.STOPPING` during the execution of this method. Changing state will trigger the `Lifecycle.STOP_EVENT` event.

  Throws:
    `LifecycleException`

### destroy

    public final void destroy()
                       throws LifecycleException

  Description copied from interface: `Lifecycle`
  Prepare to discard the object. The following `LifecycleEvent`s will be fired in the following order:
  1. DESTROY_EVENT: On the successful completion of component destruction.

  Specified by:
    `destroy` in interface `Lifecycle`
  Throws:
    `LifecycleException` - if this component detects a fatal error that prevents this component from being used

### destroyInternal

    protected abstract void destroyInternal()
                                     throws LifecycleException

  Throws:
    `LifecycleException`

### getState

    public LifecycleState getState()

  Obtain the current state of the source component.

  Specified by:
    `getState` in interface `Lifecycle`
  Returns:
    The current state of the source component.

### getStateName

    public String getStateName()

  Obtain a textual representation of the current component state. Useful for JMX.

  Specified by:
    `getStateName` in interface `Lifecycle`

### setState

    protected void setState(LifecycleState state)
                     throws LifecycleException

  Provides a mechanism for sub-classes to update the component state. Calling this method will automatically fire any associated `Lifecycle` event. It will also check that any attempted state transition is valid for a sub-class.

  Parameters:
    `state` - The new state for this component
  Throws:
    `LifecycleException`

### setState

    protected void setState(LifecycleState state,
                            Object data)
                     throws LifecycleException

  Provides a mechanism for sub-classes to update the component state. Calling this method will automatically fire any associated `Lifecycle` event. It will also check that any attempted state transition is valid for a sub-class.

  Parameters:
    `state` - The new state for this component
    `data` - The data to pass to the associated `Lifecycle` event
  Throws:
    `LifecycleException`

Overview | Package | Class | Tree | Deprecated | Index | Help
| Apache Tomcat 7.0.29
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2000-2012 Apache Software Foundation. All Rights Reserved.