Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The 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:
  Serializable, TargetClassAware, TargetSource, BeanFactoryAware

Direct Known Subclasses:
  AbstractPrototypeBasedTargetSource, LazyInitTargetSource, SimpleBeanTargetSource

    public abstract class AbstractBeanFactoryBasedTargetSource

extends Object
implements TargetSource, 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`, `CommonsPoolTargetSource`, Serialized Form

Field Summary
`protected 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(Object other)`
`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()`
`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.
`void` | `setBeanFactory(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()`
`protected Object` | `writeReplace()` Replaces this object with a SingletonTargetSource on serialization.

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 Log logger

  Logger available to subclasses

Constructor Detail

### AbstractBeanFactoryBasedTargetSource

    public AbstractBeanFactoryBasedTargetSource()

Method Detail

### 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(BeanFactory beanFactory)
                        throws BeansException

  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.
  Throws:
    `BeansException` - in case of initialization errors
  See Also:
    `BeanInitializationException`

### getBeanFactory

    public BeanFactory getBeanFactory()

  Return the owning BeanFactory.

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

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

### 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

### writeReplace

    protected Object writeReplace()
                           throws ObjectStreamException

  Replaces this object with a SingletonTargetSource on serialization. Protected as otherwise it won't be invoked for subclasses. (The `writeReplace()` method must be visible to the class being serialized.)

  With this implementation of this method, there is no need to mark non-serializable fields in this class or subclasses as transient.

  Throws:
    `ObjectStreamException`

### equals

    public boolean equals(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`

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

Copyright © 2002-2008 The Spring Framework.