SmartLifecycle (Spring Framework 3.2.1.RELEASE API)
Date: 2013-01-24

org.springframework.context

## Interface SmartLifecycle

- All Superinterfaces:
    Lifecycle, Phased
  All Known Implementing Classes:
    AbstractJmsListeningContainer, AbstractMessageListenerContainer, AbstractPollingMessageListenerContainer, DefaultMessageListenerContainer, DefaultMessageListenerContainer102, GenericMessageEndpointManager, JmsMessageEndpointManager, SchedulerFactoryBean, SimpleMessageListenerContainer, SimpleMessageListenerContainer102

      public interface SmartLifecycle
      extends Lifecycle, Phased

  An extension of the `Lifecycle` interface 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 `Phased.getPhase()` method's 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 (Integer.MIN_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.

  Any Lifecycle components within the context that do not also implement SmartLifecycle will be treated as if they have a phase value of 0. That way a SmartLifecycle implementation may start before those 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, a SmartLifecycle bean instance will 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 SmartLifecycle beans.

  Since:
    3.0
  Author:
    Mark Fisher

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `isAutoStartup()` Return whether this Lifecycle component should be started automatically by the container when the ApplicationContext is refreshed.
    `void` | `stop(Runnable callback)` Indicates that a Lifecycle component must stop if it is currently running.

    - ### Methods inherited from interface org.springframework.context.Lifecycle

      `isRunning, start, stop`

    - ### Methods inherited from interface org.springframework.context.Phased

      `getPhase`

- - ### Method Detail

    - #### isAutoStartup

          boolean isAutoStartup()

      Return whether this Lifecycle component should be started automatically by the container when the ApplicationContext is refreshed. A value of "false" indicates that the component is intended to be started manually.

    - #### stop

          void stop(Runnable callback)

      Indicates that a Lifecycle component must stop if it is currently running.

      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 the SmartLifecycle component does indeed stop.

      The `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 this method.