public interface SmartLifecycle extends Lifecycle, Phased
Lifecycleinterface for those objects that require to be started upon ApplicationContext refresh and/or shutdown in a particular order. The
isAutoStartup()return value indicates whether this object should be started at the time of a context refresh. The callback-accepting
stop(Runnable)method is useful for objects that have an asynchronous shutdown process. Any implementation of this interface must invoke the callback's
run()method upon shutdown completion to avoid unnecessary delays in the overall ApplicationContext shutdown.
This interface extends
Phased, and the
return value indicates the phase within which this Lifecycle component should
be started and stopped. The startup process begins with the lowest phase
value and ends with the highest phase value (
is the lowest possible, and
Integer.MAX_VALUE is the highest possible).
The shutdown process will apply the reverse order. Any components with the
same value will be arbitrarily ordered within the same phase.
Example: if component B depends on component A having already started, then component A should have a lower phase value than component B. During the shutdown process, component B would be stopped before component A.
Any explicit "depends-on" relationship will take precedence over the phase order such that the dependent bean always starts after its dependency and always stops before its dependency.
Lifecycle components within the context that do not also
SmartLifecycle will be treated as if they have a phase
value of 0. That way a
SmartLifecycle implementation may start
Lifecycle components if it has a negative phase value,
or it may start after those components if it has a positive phase value.
Note that, due to the auto-startup support in
SmartLifecycle bean instance will usually get initialized on startup
of the application context in any case. As a consequence, the bean definition
lazy-init flag has very limited actual effect on
|Modifier and Type||Field and Description|
The default phase for
|Modifier and Type||Method and Description|
Return the phase that this lifecycle object is supposed to run in.
Indicates that a Lifecycle component must stop if it is currently running.
static final int DEFAULT_PHASE
This is different from the common phase 0 associated with regular
Lifecycle implementations, putting the typically auto-started
SmartLifecycle beans into a separate later shutdown phase.
DefaultLifecycleProcessor.getPhase(Lifecycle), Constant Field Values
default boolean isAutoStartup()
Lifecyclecomponent should get started automatically by the container at the time that the containing
A value of
false indicates that the component is intended to
be started through an explicit
Lifecycle.start() call instead, analogous
to a plain
The default implementation returns
default void stop(Runnable callback)
The provided callback is used by the
LifecycleProcessor to support
an ordered, and potentially concurrent, shutdown of all components having a
common shutdown order value. The callback must be executed after
SmartLifecycle component does indeed stop.
LifecycleProcessor will call only this variant of the
stop method; i.e.
Lifecycle.stop() will not be called for
SmartLifecycle implementations unless explicitly delegated to within
the implementation of this method.
The default implementation delegates to
Lifecycle.stop() and immediately
triggers the given callback in the calling thread. Note that there is no
synchronization between the two, so custom implementations may at least
want to put the same steps within their common lifecycle monitor (if any).
default int getPhase()
The default implementation returns
DEFAULT_PHASE in order to
let stop callbacks execute after regular