public interface Lifecycle
Lifecycle
are:
start()
-----------------------------
| |
| init() |
NEW -»-- INITIALIZING |
| | | | ------------------«-----------------------
| | |auto | | |
| | \|/ start() \|/ \|/ auto auto stop() |
| | INITIALIZED --»-- STARTING_PREP --»- STARTING --»- STARTED --»--- |
| | | | |
| |destroy()| | |
| --»-----«-- ------------------------«-------------------------------- ^
| | | |
| | \|/ auto auto start() |
| | STOPPING_PREP ----»---- STOPPING ------»----- STOPPED -----»-----
| \|/ ^ | ^
| | stop() | | |
| | -------------------------- | |
| | | | |
| | | destroy() destroy() | |
| | FAILED ----»------ DESTROYING ---«----------------- |
| | ^ | |
| | destroy() | |auto |
| --------»----------------- \|/ |
| DESTROYED |
| |
| stop() |
----»-----------------------------»------------------------------
Any state can transition to FAILED.
Calling start() while a component is in states STARTING_PREP, STARTING or
STARTED has no effect.
Calling start() while a component is in state NEW will cause init() to be
called immediately after the start() method is entered.
Calling stop() while a component is in states STOPPING_PREP, STOPPING or
STOPPED has no effect.
Calling stop() while a component is in state NEW transitions the component
to STOPPED. This is typically encountered when a component fails to start and
does not start all its sub-components. When the component is stopped, it will
try to stop all sub-components - even those it didn't start.
Attempting any other transition will throw LifecycleException.
The LifecycleEvents fired during state changes are defined in the
methods that trigger the changed. No LifecycleEvents are fired if the
attempted transition is not valid.| Modifier and Type | Interface and Description |
|---|---|
static interface |
Lifecycle.SingleUse
Marker interface used to indicate that the instance should only be used
once.
|
| Modifier and Type | Field and Description |
|---|---|
static java.lang.String |
AFTER_DESTROY_EVENT
The LifecycleEvent type for the "component after destroy" event.
|
static java.lang.String |
AFTER_INIT_EVENT
The LifecycleEvent type for the "component after init" event.
|
static java.lang.String |
AFTER_START_EVENT
The LifecycleEvent type for the "component after start" event.
|
static java.lang.String |
AFTER_STOP_EVENT
The LifecycleEvent type for the "component after stop" event.
|
static java.lang.String |
BEFORE_DESTROY_EVENT
The LifecycleEvent type for the "component before destroy" event.
|
static java.lang.String |
BEFORE_INIT_EVENT
The LifecycleEvent type for the "component before init" event.
|
static java.lang.String |
BEFORE_START_EVENT
The LifecycleEvent type for the "component before start" event.
|
static java.lang.String |
BEFORE_STOP_EVENT
The LifecycleEvent type for the "component before stop" event.
|
static java.lang.String |
CONFIGURE_START_EVENT
The LifecycleEvent type for the "configure_start" event.
|
static java.lang.String |
CONFIGURE_STOP_EVENT
The LifecycleEvent type for the "configure_stop" event.
|
static java.lang.String |
PERIODIC_EVENT
The LifecycleEvent type for the "periodic" event.
|
static java.lang.String |
START_EVENT
The LifecycleEvent type for the "component start" event.
|
static java.lang.String |
STOP_EVENT
The LifecycleEvent type for the "component stop" event.
|
| Modifier and Type | Method and Description |
|---|---|
void |
addLifecycleListener(LifecycleListener listener)
Add a LifecycleEvent listener to this component.
|
void |
destroy()
Prepare to discard the object.
|
LifecycleListener[] |
findLifecycleListeners()
Get the life cycle listeners associated with this life cycle.
|
LifecycleState |
getState()
Obtain the current state of the source component.
|
java.lang.String |
getStateName()
Obtain a textual representation of the current component state.
|
void |
init()
Prepare the component for starting.
|
void |
removeLifecycleListener(LifecycleListener listener)
Remove a LifecycleEvent listener from this component.
|
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.
|
void |
stop()
Gracefully terminate the active use of the public methods other than
property getters/setters and life cycle methods of this component.
|
static final java.lang.String BEFORE_INIT_EVENT
static final java.lang.String AFTER_INIT_EVENT
static final java.lang.String START_EVENT
static final java.lang.String BEFORE_START_EVENT
static final java.lang.String AFTER_START_EVENT
static final java.lang.String STOP_EVENT
static final java.lang.String BEFORE_STOP_EVENT
static final java.lang.String AFTER_STOP_EVENT
static final java.lang.String AFTER_DESTROY_EVENT
static final java.lang.String BEFORE_DESTROY_EVENT
static final java.lang.String PERIODIC_EVENT
static final java.lang.String CONFIGURE_START_EVENT
BEFORE_START_EVENT and before START_EVENT.static final java.lang.String CONFIGURE_STOP_EVENT
STOP_EVENT and before AFTER_STOP_EVENT.void addLifecycleListener(LifecycleListener listener)
listener - The listener to addLifecycleListener[] findLifecycleListeners()
void removeLifecycleListener(LifecycleListener listener)
listener - The listener to removevoid init()
throws LifecycleException
LifecycleEvents will be fired in the following order:
LifecycleException - if this component detects a fatal error
that prevents this component from being usedvoid start()
throws LifecycleException
LifecycleEvents will be fired in the
following order:
LifecycleState.STARTING_PREP.LifecycleState.STARTING
and that the public methods other than property
getters/setters and life cycle methods may be
used.LifecycleState.STARTED.
LifecycleException - if this component detects a fatal error
that prevents this component from being usedvoid stop()
throws LifecycleException
LifecycleEvents will be fired in the following order:
LifecycleState.STOPPING_PREP.LifecycleState.STOPPING
and that the public methods other than property
getters/setters and life cycle methods may no longer be
used.LifecycleState.STOPPED.
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_PREPLifecycleException - if this component detects a fatal error
that needs to be reportedvoid destroy()
throws LifecycleException
LifecycleEvents will
be fired in the following order:
LifecycleException - if this component detects a fatal error
that prevents this component from being usedLifecycleState getState()
java.lang.String getStateName()
getState().Copyright © 2000-2019 Apache Software Foundation. All Rights Reserved.