The Spring Framework

## org.springframework.beans.factory.config
Class AbstractFactoryBean

    java.lang.Object
      org.springframework.beans.factory.config.AbstractFactoryBean

All Implemented Interfaces:
  BeanClassLoaderAware, BeanFactoryAware, DisposableBean, FactoryBean, InitializingBean

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

    public abstract class AbstractFactoryBean

extends Object
implements FactoryBean, 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
`protected Log` `logger` Logger available to subclasses

Constructor Summary
`AbstractFactoryBean()`

Method Summary
`void` `afterPropertiesSet()` Eagerly create the singleton instance, if necessary.
`protected abstract Object` `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(Object 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.
`Object` `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?
`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 else.

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 else. 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`
  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 Object getObject()
                           throws Exception

  Expose the singleton instance or create a new prototype instance.

  Specified by:
    `getObject` in interface `FactoryBean`
  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`
  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 Object 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(Object 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()`

The Spring Framework

Copyright © 2002-2008 The Spring Framework.