Package org.springframework.aop.target

# Class AbstractBeanFactoryBasedTargetSource

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

All Implemented Interfaces:
  `Serializable`, `TargetClassAware`, `TargetSource`, `org.springframework.beans.factory.Aware`, `org.springframework.beans.factory.BeanFactoryAware`

Direct Known Subclasses:
  `AbstractPrototypeBasedTargetSource`, `LazyInitTargetSource`, `SimpleBeanTargetSource`

public abstract class AbstractBeanFactoryBasedTargetSource extends Object implements TargetSource, org.springframework.beans.factory.BeanFactoryAware, 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`
  - `CommonsPool2TargetSource`
  - Serialized Form

## Field Summary

Fields
Modifier and Type
Field
Description
`protected final org.apache.commons.logging.Log`
`logger`
Logger available to subclasses.

## Constructor Summary

Constructors
Constructor
Description
`AbstractBeanFactoryBasedTargetSource()`

## Method Summary

Modifier and Type
Method
Description
`protected void`
`copyFrom(AbstractBeanFactoryBasedTargetSource other)`
Copy configuration from the other AbstractBeanFactoryBasedTargetSource object.
`boolean`
`equals(Object other)`
`org.springframework.beans.factory.BeanFactory`
`getBeanFactory()`
Return the owning BeanFactory.
`String`
`getTargetBeanName()`
Return the name of the target bean in the factory.
`Class<?>`
`getTargetClass()`
Return the type of targets returned by this `TargetSource`.
`int`
`hashCode()`
`void`
`setBeanFactory(org.springframework.beans.factory.BeanFactory beanFactory)`
Set the owning BeanFactory.
`void`
`setTargetBeanName(String targetBeanName)`
Set the name of the target bean in the factory.
`void`
`setTargetClass(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).
`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, isStatic, releaseTarget`

## Field Details

### logger

protected final transient org.apache.commons.logging.Log logger
Logger available to subclasses.

## Constructor Details

### AbstractBeanFactoryBasedTargetSource

public AbstractBeanFactoryBasedTargetSource()

## Method Details

### setTargetBeanName

public void setTargetBeanName(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 String getTargetBeanName()
Return the name of the target bean in the factory.

### setTargetClass

public void setTargetClass(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(org.springframework.beans.factory.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 `org.springframework.beans.factory.BeanFactoryAware`

### getBeanFactory

public org.springframework.beans.factory.BeanFactory getBeanFactory()
Return the owning BeanFactory.

### getTargetClass

@Nullable 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`

### 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(@Nullable Object other)

Overrides:
  `equals` in class `Object`

### hashCode

public int hashCode()

Overrides:
  `hashCode` in class `Object`

### toString

public String toString()

Overrides:
  `toString` in class `Object`