org.springframework.beans.factory.config

## Class AbstractFactoryBean<T>

- java.lang.Object
- - org.springframework.beans.factory.config.AbstractFactoryBean<T>

All Implemented Interfaces:
  Aware, BeanClassLoaderAware, BeanFactoryAware, DisposableBean, FactoryBean<T>, InitializingBean

Direct Known Subclasses:
  AbstractServiceLoaderBasedFactoryBean, ListFactoryBean, MapFactoryBean, ObjectFactoryCreatingFactoryBean, ProviderCreatingFactoryBean, SetFactoryBean, SortedResourcesFactoryBean

    public abstract class AbstractFactoryBean<T>
    extends Object
    implements FactoryBean<T>, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean

Simple template superclass for `FactoryBean` implementations that creates a singleton or a prototype object, depending on a flag.

If the "singleton" flag is `true` (the default), this class will create the object that it creates exactly once on initialization and subsequently return said singleton instance on all calls to the `getObject()` method.

Else, this class will create a new instance every time the `getObject()` method is invoked. Subclasses are responsible for implementing the abstract `createInstance()` template method to actually create the object(s) to expose.

Since:
  1.0.2
Author:
  Juergen Hoeller, Keith Donald
See Also:
  `setSingleton(boolean)`, `createInstance()`

### Field Summary

Fields
`protected Log` `logger` Logger available to subclasses

### Constructor Summary

Constructors
Constructor and Description
`AbstractFactoryBean()`

### Method Summary

Methods
`void` `afterPropertiesSet()` Eagerly create the singleton instance, if necessary.
`protected abstract T` `createInstance()` Template method that subclasses must override to construct the object returned by this factory.
`void` `destroy()` Destroy the singleton instance, if any.
`protected void` `destroyInstance(T instance)` Callback for destroying a singleton instance.
`protected BeanFactory` `getBeanFactory()` Return the BeanFactory that this bean runs in.
`protected TypeConverter` `getBeanTypeConverter()` Obtain a bean type converter from the BeanFactory that this bean runs in.
`protected Class[]` `getEarlySingletonInterfaces()` Return an array of interfaces that a singleton object exposed by this FactoryBean is supposed to implement, for use with an 'early singleton proxy' that will be exposed in case of a circular reference.
`T` `getObject()` Expose the singleton instance or create a new prototype instance.
`abstract Class<?>` `getObjectType()` This abstract method declaration mirrors the method in the FactoryBean interface, for a consistent offering of abstract template methods.
`boolean` `isSingleton()` Is the object managed by this factory a singleton? That is, will `FactoryBean.getObject()` always return the same object (a reference that can be cached)?
`void` `setBeanClassLoader(ClassLoader classLoader)` Callback that supplies the bean `class loader` to a bean instance.
`void` `setBeanFactory(BeanFactory beanFactory)` Callback that supplies the owning factory to a bean instance.
`void` `setSingleton(boolean singleton)` Set if a singleton should be created, or a new object on each request otherwise.

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

#### AbstractFactoryBean

    public AbstractFactoryBean()

### Method Detail

#### setSingleton

    public void setSingleton(boolean singleton)

Set if a singleton should be created, or a new object on each request otherwise. Default is `true` (a singleton).

#### isSingleton

    public boolean isSingleton()

Description copied from interface: `FactoryBean`
Is the object managed by this factory a singleton? That is, will `FactoryBean.getObject()` always return the same object (a reference that can be cached)?

NOTE: If a FactoryBean indicates to hold a singleton object, the object returned from `getObject()` might get cached by the owning BeanFactory. Hence, do not return `true` unless the FactoryBean always exposes the same reference.

The singleton status of the FactoryBean itself will generally be provided by the owning BeanFactory; usually, it has to be defined as singleton there.

NOTE: This method returning `false` does not necessarily indicate that returned objects are independent instances. An implementation of the extended `SmartFactoryBean` interface may explicitly indicate independent instances through its `SmartFactoryBean.isPrototype()` method. Plain `FactoryBean` implementations which do not implement this extended interface are simply assumed to always return independent instances if the `isSingleton()` implementation returns `false`.

Specified by:
  `isSingleton` in interface `FactoryBean<T>`
Returns:
  whether the exposed object is a singleton
See Also:
  `FactoryBean.getObject()`, `SmartFactoryBean.isPrototype()`

#### setBeanClassLoader

    public void setBeanClassLoader(ClassLoader classLoader)

Description copied from interface: `BeanClassLoaderAware`
Callback that supplies the bean `class loader` to a bean instance.

Invoked after the population of normal bean properties but before an initialization callback such as `InitializingBean's` `InitializingBean.afterPropertiesSet()` method or a custom init-method.

Specified by:
  `setBeanClassLoader` in interface `BeanClassLoaderAware`
Parameters:
  `classLoader` - the owning class loader; may be `null` in which case a default `ClassLoader` must be used, for example the `ClassLoader` obtained via `ClassUtils.getDefaultClassLoader()`

#### setBeanFactory

    public void setBeanFactory(BeanFactory beanFactory)

Description copied from interface: `BeanFactoryAware`
Callback that supplies the owning factory to a bean instance.

Invoked after the population of normal bean properties but before an initialization callback such as `InitializingBean.afterPropertiesSet()` or a custom init-method.

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

    protected BeanFactory getBeanFactory()

Return the BeanFactory that this bean runs in.

#### getBeanTypeConverter

    protected TypeConverter getBeanTypeConverter()

Obtain a bean type converter from the BeanFactory that this bean runs in. This is typically a fresh instance for each call, since TypeConverters are usually not thread-safe.

Falls back to a SimpleTypeConverter when not running in a BeanFactory.

See Also:
  `ConfigurableBeanFactory.getTypeConverter()`, `SimpleTypeConverter`

#### afterPropertiesSet

    public void afterPropertiesSet()
                            throws Exception

Eagerly create the singleton instance, if necessary.

Specified by:
  `afterPropertiesSet` in interface `InitializingBean`
Throws:
  `Exception` - in the event of misconfiguration (such as failure to set an essential property) or if initialization fails.

#### getObject

    public final T getObject()
                      throws Exception

Expose the singleton instance or create a new prototype instance.

Specified by:
  `getObject` in interface `FactoryBean<T>`
Returns:
  an instance of the bean (can be `null`)
Throws:
  `Exception` - in case of creation errors
See Also:
  `createInstance()`, `getEarlySingletonInterfaces()`

#### destroy

    public void destroy()
                 throws Exception

Destroy the singleton instance, if any.

Specified by:
  `destroy` in interface `DisposableBean`
Throws:
  `Exception` - in case of shutdown errors. Exceptions will get logged but not rethrown to allow other beans to release their resources too.
See Also:
  `destroyInstance(Object)`

#### getObjectType

    public abstract Class<?> getObjectType()

This abstract method declaration mirrors the method in the FactoryBean interface, for a consistent offering of abstract template methods.

Specified by:
  `getObjectType` in interface `FactoryBean<T>`
Returns:
  the type of object that this FactoryBean creates, or `null` if not known at the time of the call
See Also:
  `FactoryBean.getObjectType()`

#### createInstance

    protected abstract T createInstance()
                                 throws Exception

Template method that subclasses must override to construct the object returned by this factory.

Invoked on initialization of this FactoryBean in case of a singleton; else, on each `getObject()` call.

Returns:
  the object returned by this factory
Throws:
  `Exception` - if an exception occured during object creation
See Also:
  `getObject()`

#### getEarlySingletonInterfaces

    protected Class[] getEarlySingletonInterfaces()

Return an array of interfaces that a singleton object exposed by this FactoryBean is supposed to implement, for use with an 'early singleton proxy' that will be exposed in case of a circular reference.

The default implementation returns this FactoryBean's object type, provided that it is an interface, or `null` else. The latter indicates that early singleton access is not supported by this FactoryBean. This will lead to a FactoryBeanNotInitializedException getting thrown.

Returns:
  the interfaces to use for 'early singletons', or `null` to indicate a FactoryBeanNotInitializedException
See Also:
  `FactoryBeanNotInitializedException`

#### destroyInstance

    protected void destroyInstance(T instance)
                            throws Exception

Callback for destroying a singleton instance. Subclasses may override this to destroy the previously created instance.

The default implementation is empty.

Parameters:
  `instance` - the singleton instance, as returned by `createInstance()`
Throws:
  `Exception` - in case of shutdown errors
See Also:
  `createInstance()`