Overview | Package | Class | Tree | Deprecated | Index | Help
| Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.aop.target
Class AbstractBeanFactoryBasedTargetSource

    java.lang.Object
      org.springframework.aop.target.AbstractBeanFactoryBasedTargetSource

All Implemented Interfaces:
  java.io.Serializable, TargetClassAware, TargetSource, Aware, BeanFactoryAware

Direct Known Subclasses:
  AbstractPrototypeBasedTargetSource, LazyInitTargetSource, SimpleBeanTargetSource

    public abstract class AbstractBeanFactoryBasedTargetSource

extends java.lang.Object
implements TargetSource, BeanFactoryAware, java.io.Serializable

Base class for `TargetSource` implementations that are based on a Spring `BeanFactory`, delegating to Spring-managed bean instances.

Subclasses can create prototype instances or lazily access a singleton target, for example. See `LazyInitTargetSource` and `AbstractPrototypeBasedTargetSource`'s subclasses for concrete strategies.

BeanFactory-based TargetSources are serializable. This involves disconnecting the current target and turning into a `SingletonTargetSource`.

Since:
  1.1.4
Author:
  Juergen Hoeller, Rod Johnson
See Also:
  `BeanFactory.getBean(java.lang.String)`, `LazyInitTargetSource`, `PrototypeTargetSource`, `ThreadLocalTargetSource`, `CommonsPoolTargetSource`, Serialized Form

Field Summary
`protected org.apache.commons.logging.Log` | `logger` Logger available to subclasses

Constructor Summary
`AbstractBeanFactoryBasedTargetSource()`

Method Summary
`protected void` | `copyFrom(AbstractBeanFactoryBasedTargetSource other)` Copy configuration from the other AbstractBeanFactoryBasedTargetSource object.
`boolean` | `equals(java.lang.Object other)`
`BeanFactory` | `getBeanFactory()` Return the owning BeanFactory.
`java.lang.String` | `getTargetBeanName()` Return the name of the target bean in the factory.
`java.lang.Class<?>` | `getTargetClass()` Return the type of targets returned by this `TargetSource`.
`int` | `hashCode()`
`boolean` | `isStatic()` Will all calls to `TargetSource.getTarget()` return the same object?
`void` | `releaseTarget(java.lang.Object target)` Release the given target object obtained from the `TargetSource.getTarget()` method.
`void` | `setBeanFactory(BeanFactory beanFactory)` Set the owning BeanFactory.
`void` | `setTargetBeanName(java.lang.String targetBeanName)` Set the name of the target bean in the factory.
`void` | `setTargetClass(java.lang.Class targetClass)` Specify the target class explicitly, to avoid any kind of access to the target bean (for example, to avoid initialization of a FactoryBean instance).
`java.lang.String` | `toString()`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface org.springframework.aop.TargetSource
`getTarget`

Field Detail

### logger

    protected final org.apache.commons.logging.Log logger

  Logger available to subclasses

Constructor Detail

### AbstractBeanFactoryBasedTargetSource

    public AbstractBeanFactoryBasedTargetSource()

Method Detail

### setTargetBeanName

    public void setTargetBeanName(java.lang.String targetBeanName)

  Set the name of the target bean in the factory.

  The target bean should not be a singleton, else the same instance will always be obtained from the factory, resulting in the same behavior as provided by `SingletonTargetSource`.

  Parameters:
    `targetBeanName` - name of the target bean in the BeanFactory that owns this interceptor
  See Also:
    `SingletonTargetSource`

### getTargetBeanName

    public java.lang.String getTargetBeanName()

  Return the name of the target bean in the factory.

### setTargetClass

    public void setTargetClass(java.lang.Class targetClass)

  Specify the target class explicitly, to avoid any kind of access to the target bean (for example, to avoid initialization of a FactoryBean instance).

  Default is to detect the type automatically, through a `getType` call on the BeanFactory (or even a full `getBean` call as fallback).

### setBeanFactory

    public void setBeanFactory(BeanFactory beanFactory)

  Set the owning BeanFactory. We need to save a reference so that we can use the `getBean` method on every invocation.

  Specified by:
    `setBeanFactory` in interface `BeanFactoryAware`
  Parameters:
    `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
  See Also:
    `BeanInitializationException`

### getBeanFactory

    public BeanFactory getBeanFactory()

  Return the owning BeanFactory.

### getTargetClass

    public java.lang.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()

  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()`

### releaseTarget

    public void releaseTarget(java.lang.Object target)
                       throws java.lang.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:
    `java.lang.Exception` - if the object can't be released

### copyFrom

    protected void copyFrom(AbstractBeanFactoryBasedTargetSource other)

  Copy configuration from the other AbstractBeanFactoryBasedTargetSource object. Subclasses should override this if they wish to expose it.

  Parameters:
    `other` - object to copy configuration from

### equals

    public boolean equals(java.lang.Object other)

  Overrides:
    `equals` in class `java.lang.Object`

### hashCode

    public int hashCode()

  Overrides:
    `hashCode` in class `java.lang.Object`

### toString

    public java.lang.String toString()

  Overrides:
    `toString` in class `java.lang.Object`

Overview | Package | Class | Tree | Deprecated | Index | Help
| Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD