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

org.springframework.context.support

## Class DefaultLifecycleProcessor

- java.lang.Object
- - org.springframework.context.support.DefaultLifecycleProcessor

- All Implemented Interfaces:
    Aware, BeanFactoryAware, Lifecycle, LifecycleProcessor

      public class DefaultLifecycleProcessor
      extends Object
      implements LifecycleProcessor, BeanFactoryAware

  Default implementation of the `LifecycleProcessor` strategy.
  Since:
    3.0
  Author:
    Mark Fisher, Juergen Hoeller

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `DefaultLifecycleProcessor()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected Map<String,Lifecycle>` | `getLifecycleBeans()` Retrieve all applicable Lifecycle beans: all singletons that have already been created, as well as all SmartLifecycle beans (even if they are marked as lazy-init).
    `protected int` | `getPhase(Lifecycle bean)` Determine the lifecycle phase of the given bean.
    `boolean` | `isRunning()` Check whether this component is currently running.
    `void` | `onClose()` Notification of context close phase, e.g.
    `void` | `onRefresh()` Notification of context refresh, e.g.
    `void` | `setBeanFactory(BeanFactory beanFactory)` Callback that supplies the owning factory to a bean instance.
    `void` | `setTimeoutPerShutdownPhase(long timeoutPerShutdownPhase)` Specify the maximum time allotted in milliseconds for the shutdown of any phase (group of SmartLifecycle beans with the same 'phase' value).
    `void` | `start()` Start all registered beans that implement Lifecycle and are not already running.
    `void` | `stop()` Stop all registered beans that implement Lifecycle and are currently running.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### DefaultLifecycleProcessor

          public DefaultLifecycleProcessor()

  - ### Method Detail

    - #### setTimeoutPerShutdownPhase

          public void setTimeoutPerShutdownPhase(long timeoutPerShutdownPhase)

      Specify the maximum time allotted in milliseconds for the shutdown of any phase (group of SmartLifecycle beans with the same 'phase' value). The default value is 30 seconds.

    - #### setBeanFactory

          public void setBeanFactory(BeanFactory beanFactory)

      Description copied from interface: `BeanFactoryAware`
      Callback that supplies the owning factory to a bean instance.

      Invoked after the population of normal bean properties but before an initialization callback such as `InitializingBean.afterPropertiesSet()` or a custom init-method.

      Specified by:
        `setBeanFactory` in interface `BeanFactoryAware`
      Parameters:
        `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
      See Also:
        `BeanInitializationException`

    - #### start

          public void start()

      Start all registered beans that implement Lifecycle and are not already running. Any bean that implements SmartLifecycle will be started within its 'phase', and all phases will be ordered from lowest to highest value. All beans that do not implement SmartLifecycle will be started in the default phase 0. A bean declared as a dependency of another bean will be started before the dependent bean regardless of the declared phase.
      Specified by:
        `start` in interface `Lifecycle`

    - #### stop

          public void stop()

      Stop all registered beans that implement Lifecycle and are currently running. Any bean that implements SmartLifecycle will be stopped within its 'phase', and all phases will be ordered from highest to lowest value. All beans that do not implement SmartLifecycle will be stopped in the default phase 0. A bean declared as dependent on another bean will be stopped before the dependency bean regardless of the declared phase.
      Specified by:
        `stop` in interface `Lifecycle`
      See Also:
        `SmartLifecycle.stop(Runnable)`

    - #### onRefresh

          public void onRefresh()

      Description copied from interface: `LifecycleProcessor`
      Notification of context refresh, e.g. for auto-starting components.
      Specified by:
        `onRefresh` in interface `LifecycleProcessor`

    - #### onClose

          public void onClose()

      Description copied from interface: `LifecycleProcessor`
      Notification of context close phase, e.g. for auto-stopping components.
      Specified by:
        `onClose` in interface `LifecycleProcessor`

    - #### isRunning

          public boolean isRunning()

      Description copied from interface: `Lifecycle`
      Check whether this component is currently running.

      In the case of a container, this will return `true` only if all components that apply are currently running.

      Specified by:
        `isRunning` in interface `Lifecycle`
      Returns:
        whether the component is currently running

    - #### getLifecycleBeans

          protected Map<String,Lifecycle> getLifecycleBeans()

      Retrieve all applicable Lifecycle beans: all singletons that have already been created, as well as all SmartLifecycle beans (even if they are marked as lazy-init).
      Returns:
        the Map of applicable beans, with bean names as keys and bean instances as values

    - #### getPhase

          protected int getPhase(Lifecycle bean)

      Determine the lifecycle phase of the given bean.

      The default implementation checks for the `Phased` interface. Can be overridden to apply other/further policies.

      Parameters:
        `bean` - the bean to introspect
      Returns:
        the phase an an integer value. The suggested default is 0.
      See Also:
        `Phased`, `SmartLifecycle`