org.springframework.aop.target.dynamic

## Class AbstractRefreshableTargetSource

- java.lang.Object
- - org.springframework.aop.target.dynamic.AbstractRefreshableTargetSource

- All Implemented Interfaces:
    Refreshable, TargetClassAware, TargetSource
  Direct Known Subclasses:
    BeanFactoryRefreshableTargetSource

      public abstract class AbstractRefreshableTargetSource
      extends Object
      implements TargetSource, Refreshable

  Abstract `TargetSource` implementation that wraps a refreshable target object. Subclasses can determine whether a refresh is required, and need to provide fresh target objects.

  Implements the `Refreshable` interface in order to allow for explicit control over the refresh status.

  Since:
    2.0
  Author:
    Rod Johnson, Rob Harrop, Juergen Hoeller
  See Also:
    `requiresRefresh()`, `freshTarget()`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | `logger` Logger available to subclasses
    `protected Object` | `targetObject`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractRefreshableTargetSource()`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected abstract Object` | `freshTarget()` Obtain a fresh target object.
    `long` | `getLastRefreshTime()` Return the last time an actual refresh happened (as timestamp).
    `long` | `getRefreshCount()` Return the number of actual refreshes since startup.
    `Object` | `getTarget()` Return a target instance.
    `Class<?>` | `getTargetClass()` Return the type of targets returned by this `TargetSource`.
    `boolean` | `isStatic()` Not static.
    `void` | `refresh()` Refresh the underlying target object.
    `void` | `releaseTarget(Object object)` No need to release target.
    `protected boolean` | `requiresRefresh()` Determine whether a refresh is required.
    `void` | `setRefreshCheckDelay(long refreshCheckDelay)` Set the delay between refresh checks, in milliseconds.

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

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

- - ### Field Detail

    - #### logger

          protected Log logger

      Logger available to subclasses

    - #### targetObject

          protected Object targetObject

  - ### Constructor Detail

    - #### AbstractRefreshableTargetSource

          public AbstractRefreshableTargetSource()

  - ### Method Detail

    - #### setRefreshCheckDelay

          public void setRefreshCheckDelay(long refreshCheckDelay)

      Set the delay between refresh checks, in milliseconds. Default is -1, indicating no refresh checks at all.

      Note that an actual refresh will only happen when `requiresRefresh()` returns `true`.

    - #### getTargetClass

          public Class<?> getTargetClass()

      Description copied from interface: `TargetSource`
      Return the type of targets returned by this `TargetSource`.

      Can return `null`, although certain usages of a `TargetSource` might just work with a predetermined target class.

      Specified by:
        `getTargetClass` in interface `TargetClassAware`
      Specified by:
        `getTargetClass` in interface `TargetSource`
      Returns:
        the type of targets returned by this `TargetSource`

    - #### isStatic

          public boolean isStatic()

      Not static.
      Specified by:
        `isStatic` in interface `TargetSource`
      Returns:
        `true` if the target is immutable
      See Also:
        `TargetSource.getTarget()`

    - #### getTarget

          public final Object getTarget()

      Description copied from interface: `TargetSource`
      Return a target instance. Invoked immediately before the AOP framework calls the "target" of an AOP method invocation.
      Specified by:
        `getTarget` in interface `TargetSource`
      Returns:
        the target object, which contains the joinpoint

    - #### releaseTarget

          public void releaseTarget(Object object)

      No need to release target.
      Specified by:
        `releaseTarget` in interface `TargetSource`
      Parameters:
        `object` - object obtained from a call to `TargetSource.getTarget()`

    - #### refresh

          public final void refresh()

      Description copied from interface: `Refreshable`
      Refresh the underlying target object.
      Specified by:
        `refresh` in interface `Refreshable`

    - #### getRefreshCount

          public long getRefreshCount()

      Description copied from interface: `Refreshable`
      Return the number of actual refreshes since startup.
      Specified by:
        `getRefreshCount` in interface `Refreshable`

    - #### getLastRefreshTime

          public long getLastRefreshTime()

      Description copied from interface: `Refreshable`
      Return the last time an actual refresh happened (as timestamp).
      Specified by:
        `getLastRefreshTime` in interface `Refreshable`

    - #### requiresRefresh

          protected boolean requiresRefresh()

      Determine whether a refresh is required. Invoked for each refresh check, after the refresh check delay has elapsed.

      The default implementation always returns `true`, triggering a refresh every time the delay has elapsed. To be overridden by subclasses with an appropriate check of the underlying target resource.

      Returns:
        whether a refresh is required

    - #### freshTarget

          protected abstract Object freshTarget()

      Obtain a fresh target object.

      Only invoked if a refresh check has found that a refresh is required (that is, `requiresRefresh()` has returned `true`).

      Returns:
        the fresh target object