org.apache.catalina.util

## Class LifecycleBase

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

All Implemented Interfaces:
  Lifecycle

Direct Known Subclasses:
  LifecycleMBeanBase, 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

Constructors
Constructor and Description
`LifecycleBase()`

### Method Summary

Methods
`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`