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_START_EVENT, AFTER_STOP_EVENT, BEFORE_START_EVENT, BEFORE_STOP_EVENT, CONFIGURE_START_EVENT, CONFIGURE_STOP_EVENT, DESTROY_EVENT, INIT_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 lifecycle listeners associated with this lifecycle.
protected void	fireLifecycleEvent(String type, Object data) Allow sub classes to fire Lifecycle events.
LifecycleState	getState() Obtain the current state of the source component.
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 of this component.
protected abstract void	startInternal() Sub-classes must ensure that: the Lifecycle.START_EVENT is fired during the execution of this method the state is changed to LifecycleState.STARTING when the Lifecycle.START_EVENT is fired 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.
void	stop() Gracefully terminate the active use of the public methods of this component.
protected abstract void	stopInternal() Sub-classes must ensure that: the Lifecycle.STOP_EVENT is fired during the execution of this method the state is changed to LifecycleState.STOPPING when the Lifecycle.STOP_EVENT is fired

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 lifecycle listeners associated with this lifecycle. If this Lifecycle 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 LifecycleEvents 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 of this component. This method should be called before any of the public methods of this component are utilized. The following LifecycleEvents 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 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 Lifecycle.START_EVENT is fired during the execution of this method
• the state is changed to LifecycleState.STARTING when the Lifecycle.START_EVENT is fired

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 of this component. Once the STOP_EVENT is fired, the public methods should not be used. The following LifecycleEvents 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 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.

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 Lifecycle.STOP_EVENT is fired during the execution of this method
• the state is changed to LifecycleState.STOPPING when the Lifecycle.STOP_EVENT is fired

Throws:

LifecycleException

destroy

public final void destroy()
                   throws LifecycleException

Description copied from interface: Lifecycle

Prepare to discard the object. The following LifecycleEvents 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.

setState

protected void setState(LifecycleState state)

Provides a mechanism for sub-classes to update the component state. Calling this method will automatically fire any associated Lifecycle event.

Parameters:

state - The new state for this component

setState

protected void setState(LifecycleState state,
                        Object data)

Provides a mechanism for sub-classes to update the component state. Calling this method will automatically fire any associated Lifecycle event.

Parameters:

state - The new state for this component

data - The data to pass to the associated Lifecycle event