org.springframework.scheduling.commonj

## Class TimerManagerAccessor

- java.lang.Object
- - org.springframework.jndi.JndiAccessor
  - - org.springframework.jndi.JndiLocatorSupport
    - - org.springframework.scheduling.commonj.TimerManagerAccessor

- All Implemented Interfaces:
    DisposableBean, InitializingBean, Lifecycle
  Direct Known Subclasses:
    TimerManagerFactoryBean, TimerManagerTaskScheduler

      public abstract class TimerManagerAccessor
      extends JndiLocatorSupport
      implements InitializingBean, DisposableBean, Lifecycle

  Base class for classes that are accessing a CommonJ `TimerManager` Defines common configuration settings and common lifecycle handling.
  Since:
    3.0
  Author:
    Juergen Hoeller
  See Also:
    `TimerManager`

- - ### Field Summary

    - ### Fields inherited from class org.springframework.jndi.JndiLocatorSupport

      `CONTAINER_PREFIX`

    - ### Fields inherited from class org.springframework.jndi.JndiAccessor

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `TimerManagerAccessor()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `afterPropertiesSet()` Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
    `void` | `destroy()` Stops the underlying TimerManager (if not shared).
    `protected TimerManager` | `getTimerManager()`
    `boolean` | `isRunning()` Considers the underlying TimerManager as running if it is neither suspending nor stopping.
    `void` | `setShared(boolean shared)` Specify whether the TimerManager obtained by this FactoryBean is a shared instance ("true") or an independent instance ("false").
    `void` | `setTimerManager(TimerManager timerManager)` Specify the CommonJ TimerManager to delegate to.
    `void` | `setTimerManagerName(String timerManagerName)` Set the JNDI name of the CommonJ TimerManager.
    `void` | `start()` Resumes the underlying TimerManager (if not shared).
    `void` | `stop()` Suspends the underlying TimerManager (if not shared).

    - ### Methods inherited from class org.springframework.jndi.JndiLocatorSupport

      `convertJndiName, isResourceRef, lookup, lookup, setResourceRef`

    - ### Methods inherited from class org.springframework.jndi.JndiAccessor

      `getJndiEnvironment, getJndiTemplate, setJndiEnvironment, setJndiTemplate`

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

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

- - ### Constructor Detail

    - #### TimerManagerAccessor

          public TimerManagerAccessor()

  - ### Method Detail

    - #### setTimerManager

          public void setTimerManager(TimerManager timerManager)

      Specify the CommonJ TimerManager to delegate to.

      Note that the given TimerManager's lifecycle will be managed by this FactoryBean.

      Alternatively (and typically), you can specify the JNDI name of the target TimerManager.

      See Also:
        `setTimerManagerName(java.lang.String)`

    - #### setTimerManagerName

          public void setTimerManagerName(String timerManagerName)

      Set the JNDI name of the CommonJ TimerManager.

      This can either be a fully qualified JNDI name, or the JNDI name relative to the current environment naming context if "resourceRef" is set to "true".

      See Also:
        `setTimerManager(commonj.timers.TimerManager)`, `JndiLocatorSupport.setResourceRef(boolean)`

    - #### setShared

          public void setShared(boolean shared)

      Specify whether the TimerManager obtained by this FactoryBean is a shared instance ("true") or an independent instance ("false"). The lifecycle of the former is supposed to be managed by the application server, while the lifecycle of the latter is up to the application.

      Default is "false", i.e. managing an independent TimerManager instance. This is what the CommonJ specification suggests that application servers are supposed to offer via JNDI lookups, typically declared as a `resource-ref` of type `commonj.timers.TimerManager` in `web.xml`, with `res-sharing-scope` set to 'Unshareable'.

      Switch this flag to "true" if you are obtaining a shared TimerManager, typically through specifying the JNDI location of a TimerManager that has been explicitly declared as 'Shareable'. Note that WebLogic's cluster-aware Job Scheduler is a shared TimerManager too.

      The sole difference between this FactoryBean being in shared or non-shared mode is that it will only attempt to suspend / resume / stop the underlying TimerManager in case of an independent (non-shared) instance. This only affects the `Lifecycle` support as well as application context shutdown.

      See Also:
        `stop()`, `start()`, `destroy()`, `TimerManager`

    - #### afterPropertiesSet

          public void afterPropertiesSet()
                                  throws NamingException

      Description copied from interface: `InitializingBean`
      Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).

      This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.

      Specified by:
        `afterPropertiesSet` in interface `InitializingBean`
      Throws:
        `NamingException`

    - #### getTimerManager

          protected final TimerManager getTimerManager()

    - #### start

          public void start()

      Resumes the underlying TimerManager (if not shared).
      Specified by:
        `start` in interface `Lifecycle`
      See Also:
        `TimerManager.resume()`

    - #### stop

          public void stop()

      Suspends the underlying TimerManager (if not shared).
      Specified by:
        `stop` in interface `Lifecycle`
      See Also:
        `TimerManager.suspend()`

    - #### isRunning

          public boolean isRunning()

      Considers the underlying TimerManager as running if it is neither suspending nor stopping.
      Specified by:
        `isRunning` in interface `Lifecycle`
      Returns:
        whether the component is currently running
      See Also:
        `TimerManager.isSuspending()`, `TimerManager.isStopping()`

    - #### destroy

          public void destroy()

      Stops the underlying TimerManager (if not shared).
      Specified by:
        `destroy` in interface `DisposableBean`
      See Also:
        `TimerManager.stop()`