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
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | `logger` Logger available to subclasses

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractFactoryBean()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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()`