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
`protected Log` `logger` Logger available to subclasses

### Constructor Summary

Constructors
Constructor and Description
`AbstractLazyCreationTargetSource()`

### Method Summary

Methods
`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