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

org.springframework.aop.target

## Class AbstractLazyCreationTargetSource

- java.lang.Object
- - org.springframework.aop.target.AbstractLazyCreationTargetSource

- All Implemented Interfaces:
    TargetClassAware, TargetSource

      public abstract class AbstractLazyCreationTargetSource
      extends Object
      implements TargetSource

  `TargetSource` implementation that will lazily create a user-managed object.

  Creation of the lazy target object is controlled by the user by implementing the `createObject()` method. This `TargetSource` will invoke this method the first time the proxy is accessed.

  Useful when you need to pass a reference to some dependency to an object but you don't actually want the dependency to be created until it is first used. A typical scenario for this is a connection to a remote resource.

  Since:
    1.2.4
  Author:
    Rob Harrop, Juergen Hoeller
  See Also:
    `isInitialized()`, `createObject()`

- - ### Field Summary

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

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractLazyCreationTargetSource()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected abstract Object` | `createObject()` Subclasses should implement this method to return the lazy initialized object.
    `Object` | `getTarget()` Returns the lazy-initialized target object, creating it on-the-fly if it doesn't exist already.
    `Class<?>` | `getTargetClass()` This default implementation returns `null` if the target is `null` (it is hasn't yet been initialized), or the target class if the target has already been initialized.
    `boolean` | `isInitialized()` Return whether the lazy target object of this TargetSource has already been fetched.
    `boolean` | `isStatic()` Will all calls to `TargetSource.getTarget()` return the same object?
    `void` | `releaseTarget(Object target)` Release the given target object obtained from the `TargetSource.getTarget()` method.

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

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

- - ### Field Detail

    - #### logger

          protected final Log logger

      Logger available to subclasses

  - ### Constructor Detail

    - #### AbstractLazyCreationTargetSource

          public AbstractLazyCreationTargetSource()

  - ### Method Detail

    - #### isInitialized

          public boolean isInitialized()

      Return whether the lazy target object of this TargetSource has already been fetched.

    - #### getTargetClass

          public Class<?> getTargetClass()

      This default implementation returns `null` if the target is `null` (it is hasn't yet been initialized), or the target class if the target has already been initialized.

      Subclasses may wish to override this method in order to provide a meaningful value when the target is still `null`.

      Specified by:
        `getTargetClass` in interface `TargetClassAware`
      Specified by:
        `getTargetClass` in interface `TargetSource`
      Returns:
        the type of targets returned by this `TargetSource`
      See Also:
        `isInitialized()`

    - #### isStatic

          public boolean isStatic()

      Description copied from interface: `TargetSource`
      Will all calls to `TargetSource.getTarget()` return the same object?

      In that case, there will be no need to invoke `TargetSource.releaseTarget(Object)`, and the AOP framework can cache the return value of `TargetSource.getTarget()`.

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

    - #### getTarget

          public Object getTarget()
                           throws Exception

      Returns the lazy-initialized target object, creating it on-the-fly if it doesn't exist already.
      Specified by:
        `getTarget` in interface `TargetSource`
      Returns:
        the target object, which contains the joinpoint
      Throws:
        `Exception` - if the target object can't be resolved
      See Also:
        `createObject()`

    - #### releaseTarget

          public void releaseTarget(Object target)
                             throws Exception

      Description copied from interface: `TargetSource`
      Release the given target object obtained from the `TargetSource.getTarget()` method.
      Specified by:
        `releaseTarget` in interface `TargetSource`
      Parameters:
        `target` - object obtained from a call to `TargetSource.getTarget()`
      Throws:
        `Exception` - if the object can't be released

    - #### createObject

          protected abstract Object createObject()
                                          throws Exception

      Subclasses should implement this method to return the lazy initialized object. Called the first time the proxy is invoked.
      Returns:
        the created object
      Throws:
        `Exception` - if creation failed