org.springframework.scheduling.annotation

## Class ScheduledAnnotationBeanPostProcessor

- java.lang.Object
- - org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor

- All Implemented Interfaces:
    EventListener, Aware, BeanFactoryAware, BeanNameAware, BeanPostProcessor, DestructionAwareBeanPostProcessor, DisposableBean, SmartInitializingSingleton, MergedBeanDefinitionPostProcessor, ApplicationContextAware, ApplicationListener<ContextRefreshedEvent>, EmbeddedValueResolverAware, Ordered, ScheduledTaskHolder

      public class ScheduledAnnotationBeanPostProcessor
      extends Object
      implements ScheduledTaskHolder, MergedBeanDefinitionPostProcessor, DestructionAwareBeanPostProcessor, Ordered, EmbeddedValueResolverAware, BeanNameAware, BeanFactoryAware, ApplicationContextAware, SmartInitializingSingleton, ApplicationListener<ContextRefreshedEvent>, DisposableBean

  Bean post-processor that registers methods annotated with `@Scheduled` to be invoked by a `TaskScheduler` according to the "fixedRate", "fixedDelay", or "cron" expression provided via the annotation.

  This post-processor is automatically registered by Spring's `<task:annotation-driven>` XML element and also by the `@EnableScheduling` annotation.

  Autodetects any `SchedulingConfigurer` instances in the container, allowing for customization of the scheduler to be used or for fine-grained control over task registration (e.g. registration of `Trigger` tasks). See the `@EnableScheduling` javadocs for complete usage details.

  Since:
    3.0
  Author:
    Mark Fisher, Juergen Hoeller, Chris Beams, Elizabeth Chatman, Victor Brown, Sam Brannen
  See Also:
    `Scheduled`, `EnableScheduling`, `SchedulingConfigurer`, `TaskScheduler`, `ScheduledTaskRegistrar`, `AsyncAnnotationBeanPostProcessor`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static String` | `DEFAULT_TASK_SCHEDULER_BEAN_NAME` The default name of the `TaskScheduler` bean to pick up: "taskScheduler".
    `protected Log` | `logger`

    - ### Fields inherited from interface org.springframework.core.Ordered

      `HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ScheduledAnnotationBeanPostProcessor()` Create a default `ScheduledAnnotationBeanPostProcessor`.
    `ScheduledAnnotationBeanPostProcessor(ScheduledTaskRegistrar registrar)` Create a `ScheduledAnnotationBeanPostProcessor` delegating to the specified `ScheduledTaskRegistrar`.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `afterSingletonsInstantiated()` Invoked right at the end of the singleton pre-instantiation phase, with a guarantee that all regular singleton beans have been created already.
    `protected Runnable` | `createRunnable(Object target, Method method)` Create a `Runnable` for the given bean instance, calling the specified scheduled method.
    `void` | `destroy()` Invoked by the containing `BeanFactory` on destruction of a bean.
    `int` | `getOrder()` Get the order value of this object.
    `Set<ScheduledTask>` | `getScheduledTasks()` Return all currently scheduled tasks, from `Scheduled` methods as well as from programmatic `SchedulingConfigurer` interaction.
    `void` | `onApplicationEvent(ContextRefreshedEvent event)` Handle an application event.
    `Object` | `postProcessAfterInitialization(Object bean, String beanName)` Apply this `BeanPostProcessor` to the given new bean instance after any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method).
    `void` | `postProcessBeforeDestruction(Object bean, String beanName)` Apply this BeanPostProcessor to the given bean instance before its destruction, e.g.
    `Object` | `postProcessBeforeInitialization(Object bean, String beanName)` Apply this `BeanPostProcessor` to the given new bean instance before any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method).
    `void` | `postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)` Post-process the given merged bean definition for the specified bean.
    `protected void` | `processScheduled(Scheduled scheduled, Method method, Object bean)` Process the given `@Scheduled` method declaration on the given bean.
    `boolean` | `requiresDestruction(Object bean)` Determine whether the given bean instance requires destruction by this post-processor.
    `void` | `setApplicationContext(ApplicationContext applicationContext)` Setting an `ApplicationContext` is optional: If set, registered tasks will be activated in the `ContextRefreshedEvent` phase; if not set, it will happen at `afterSingletonsInstantiated()` time.
    `void` | `setBeanFactory(BeanFactory beanFactory)` Making a `BeanFactory` available is optional; if not set, `SchedulingConfigurer` beans won't get autodetected and a `scheduler` has to be explicitly configured.
    `void` | `setBeanName(String beanName)` Set the name of the bean in the bean factory that created this bean.
    `void` | `setEmbeddedValueResolver(StringValueResolver resolver)` Set the StringValueResolver to use for resolving embedded definition values.
    `void` | `setScheduler(Object scheduler)` Set the `TaskScheduler` that will invoke the scheduled methods, or a `ScheduledExecutorService` to be wrapped as a TaskScheduler.

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

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

    - ### Methods inherited from interface org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor

      `resetBeanDefinition`

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

      `forPayload`

- - ### Field Detail

    - #### DEFAULT_TASK_SCHEDULER_BEAN_NAME

          public static final String DEFAULT_TASK_SCHEDULER_BEAN_NAME

      The default name of the `TaskScheduler` bean to pick up: "taskScheduler".

      Note that the initial lookup happens by type; this is just the fallback in case of multiple scheduler beans found in the context.

      Since:
        4.2
      See Also:
        Constant Field Values

    - #### logger

          protected final Log logger

  - ### Constructor Detail

    - #### ScheduledAnnotationBeanPostProcessor

          public ScheduledAnnotationBeanPostProcessor()

      Create a default `ScheduledAnnotationBeanPostProcessor`.

    - #### ScheduledAnnotationBeanPostProcessor

          public ScheduledAnnotationBeanPostProcessor(ScheduledTaskRegistrar registrar)

      Create a `ScheduledAnnotationBeanPostProcessor` delegating to the specified `ScheduledTaskRegistrar`.
      Parameters:
        `registrar` - the ScheduledTaskRegistrar to register `@Scheduled` tasks on
      Since:
        5.1

  - ### Method Detail

    - #### getOrder

          public int getOrder()

      Description copied from interface: `Ordered`
      Get the order value of this object.

      Higher values are interpreted as lower priority. As a consequence, the object with the lowest value has the highest priority (somewhat analogous to Servlet `load-on-startup` values).

      Same order values will result in arbitrary sort positions for the affected objects.

      Specified by:
        `getOrder` in interface `Ordered`
      Returns:
        the order value
      See Also:
        `Ordered.HIGHEST_PRECEDENCE`, `Ordered.LOWEST_PRECEDENCE`

    - #### setScheduler

          public void setScheduler(Object scheduler)

      Set the `TaskScheduler` that will invoke the scheduled methods, or a `ScheduledExecutorService` to be wrapped as a TaskScheduler.

      If not specified, default scheduler resolution will apply: searching for a unique `TaskScheduler` bean in the context, or for a `TaskScheduler` bean named "taskScheduler" otherwise; the same lookup will also be performed for a `ScheduledExecutorService` bean. If neither of the two is resolvable, a local single-threaded default scheduler will be created within the registrar.

      See Also:
        `DEFAULT_TASK_SCHEDULER_BEAN_NAME`

    - #### setEmbeddedValueResolver

          public void setEmbeddedValueResolver(StringValueResolver resolver)

      Description copied from interface: `EmbeddedValueResolverAware`
      Set the StringValueResolver to use for resolving embedded definition values.
      Specified by:
        `setEmbeddedValueResolver` in interface `EmbeddedValueResolverAware`

    - #### setBeanName

          public void setBeanName(String beanName)

      Description copied from interface: `BeanNameAware`
      Set the name of the bean in the bean factory that created this bean.

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

      Specified by:
        `setBeanName` in interface `BeanNameAware`
      Parameters:
        `beanName` - the name of the bean in the factory. Note that this name is the actual bean name used in the factory, which may differ from the originally specified name: in particular for inner bean names, the actual bean name might have been made unique through appending "#..." suffixes. Use the `BeanFactoryUtils.originalBeanName(String)` method to extract the original bean name (without suffix), if desired.

    - #### setBeanFactory

          public void setBeanFactory(BeanFactory beanFactory)

      Making a `BeanFactory` available is optional; if not set, `SchedulingConfigurer` beans won't get autodetected and a `scheduler` has to be explicitly configured.
      Specified by:
        `setBeanFactory` in interface `BeanFactoryAware`
      Parameters:
        `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
      See Also:
        `BeanInitializationException`

    - #### setApplicationContext

          public void setApplicationContext(ApplicationContext applicationContext)

      Setting an `ApplicationContext` is optional: If set, registered tasks will be activated in the `ContextRefreshedEvent` phase; if not set, it will happen at `afterSingletonsInstantiated()` time.
      Specified by:
        `setApplicationContext` in interface `ApplicationContextAware`
      Parameters:
        `applicationContext` - the ApplicationContext object to be used by this object
      See Also:
        `BeanInitializationException`

    - #### afterSingletonsInstantiated

          public void afterSingletonsInstantiated()

      Description copied from interface: `SmartInitializingSingleton`
      Invoked right at the end of the singleton pre-instantiation phase, with a guarantee that all regular singleton beans have been created already. `ListableBeanFactory.getBeansOfType(java.lang.Class<T>)` calls within this method won't trigger accidental side effects during bootstrap.

      NOTE: This callback won't be triggered for singleton beans lazily initialized on demand after `BeanFactory` bootstrap, and not for any other bean scope either. Carefully use it for beans with the intended bootstrap semantics only.

      Specified by:
        `afterSingletonsInstantiated` in interface `SmartInitializingSingleton`

    - #### onApplicationEvent

          public void onApplicationEvent(ContextRefreshedEvent event)

      Description copied from interface: `ApplicationListener`
      Handle an application event.
      Specified by:
        `onApplicationEvent` in interface `ApplicationListener<ContextRefreshedEvent>`
      Parameters:
        `event` - the event to respond to

    - #### postProcessMergedBeanDefinition

          public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition,
                                                      Class<?> beanType,
                                                      String beanName)

      Description copied from interface: `MergedBeanDefinitionPostProcessor`
      Post-process the given merged bean definition for the specified bean.
      Specified by:
        `postProcessMergedBeanDefinition` in interface `MergedBeanDefinitionPostProcessor`
      Parameters:
        `beanDefinition` - the merged bean definition for the bean
        `beanType` - the actual type of the managed bean instance
        `beanName` - the name of the bean
      See Also:
        `AbstractAutowireCapableBeanFactory.applyMergedBeanDefinitionPostProcessors(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Class<?>, java.lang.String)`

    - #### postProcessBeforeInitialization

          public Object postProcessBeforeInitialization(Object bean,
                                                        String beanName)

      Description copied from interface: `BeanPostProcessor`
      Apply this `BeanPostProcessor` to the given new bean instance before any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method). The bean will already be populated with property values. The returned bean instance may be a wrapper around the original.

      The default implementation returns the given `bean` as-is.

      Specified by:
        `postProcessBeforeInitialization` in interface `BeanPostProcessor`
      Parameters:
        `bean` - the new bean instance
        `beanName` - the name of the bean
      Returns:
        the bean instance to use, either the original or a wrapped one; if `null`, no subsequent BeanPostProcessors will be invoked
      See Also:
        `InitializingBean.afterPropertiesSet()`

    - #### postProcessAfterInitialization

          public Object postProcessAfterInitialization(Object bean,
                                                       String beanName)

      Description copied from interface: `BeanPostProcessor`
      Apply this `BeanPostProcessor` to the given new bean instance after any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method). The bean will already be populated with property values. The returned bean instance may be a wrapper around the original.

      In case of a FactoryBean, this callback will be invoked for both the FactoryBean instance and the objects created by the FactoryBean (as of Spring 2.0). The post-processor can decide whether to apply to either the FactoryBean or created objects or both through corresponding `bean instanceof FactoryBean` checks.

      This callback will also be invoked after a short-circuiting triggered by a `InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class<?>, java.lang.String)` method, in contrast to all other `BeanPostProcessor` callbacks.

      The default implementation returns the given `bean` as-is.

      Specified by:
        `postProcessAfterInitialization` in interface `BeanPostProcessor`
      Parameters:
        `bean` - the new bean instance
        `beanName` - the name of the bean
      Returns:
        the bean instance to use, either the original or a wrapped one; if `null`, no subsequent BeanPostProcessors will be invoked
      See Also:
        `InitializingBean.afterPropertiesSet()`, `FactoryBean`

    - #### processScheduled

          protected void processScheduled(Scheduled scheduled,
                                          Method method,
                                          Object bean)

      Process the given `@Scheduled` method declaration on the given bean.
      Parameters:
        `scheduled` - the `@Scheduled` annotation
        `method` - the method that the annotation has been declared on
        `bean` - the target bean instance
      See Also:
        `createRunnable(Object, Method)`

    - #### createRunnable

          protected Runnable createRunnable(Object target,
                                            Method method)

      Create a `Runnable` for the given bean instance, calling the specified scheduled method.

      The default implementation creates a `ScheduledMethodRunnable`.

      Parameters:
        `target` - the target bean instance
        `method` - the scheduled method to call
      Since:
        5.1
      See Also:
        `ScheduledMethodRunnable(Object, Method)`

    - #### getScheduledTasks

          public Set<ScheduledTask> getScheduledTasks()

      Return all currently scheduled tasks, from `Scheduled` methods as well as from programmatic `SchedulingConfigurer` interaction.
      Specified by:
        `getScheduledTasks` in interface `ScheduledTaskHolder`
      Since:
        5.0.2

    - #### postProcessBeforeDestruction

          public void postProcessBeforeDestruction(Object bean,
                                                   String beanName)

      Description copied from interface: `DestructionAwareBeanPostProcessor`
      Apply this BeanPostProcessor to the given bean instance before its destruction, e.g. invoking custom destruction callbacks.

      Like DisposableBean's `destroy` and a custom destroy method, this callback will only apply to beans which the container fully manages the lifecycle for. This is usually the case for singletons and scoped beans.

      Specified by:
        `postProcessBeforeDestruction` in interface `DestructionAwareBeanPostProcessor`
      Parameters:
        `bean` - the bean instance to be destroyed
        `beanName` - the name of the bean
      See Also:
        `DisposableBean.destroy()`, `AbstractBeanDefinition.setDestroyMethodName(String)`

    - #### requiresDestruction

          public boolean requiresDestruction(Object bean)

      Description copied from interface: `DestructionAwareBeanPostProcessor`
      Determine whether the given bean instance requires destruction by this post-processor.

      The default implementation returns `true`. If a pre-5 implementation of `DestructionAwareBeanPostProcessor` does not provide a concrete implementation of this method, Spring silently assumes `true` as well.

      Specified by:
        `requiresDestruction` in interface `DestructionAwareBeanPostProcessor`
      Parameters:
        `bean` - the bean instance to check
      Returns:
        `true` if `DestructionAwareBeanPostProcessor.postProcessBeforeDestruction(java.lang.Object, java.lang.String)` is supposed to be called for this bean instance eventually, or `false` if not needed

    - #### destroy

          public void destroy()

      Description copied from interface: `DisposableBean`
      Invoked by the containing `BeanFactory` on destruction of a bean.
      Specified by:
        `destroy` in interface `DisposableBean`