Class ObjectFactoryCreatingFactoryBean

  extended by org.springframework.beans.factory.config.AbstractFactoryBean<ObjectFactory>
      extended by org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean
All Implemented Interfaces:
Aware, BeanClassLoaderAware, BeanFactoryAware, DisposableBean, FactoryBean<ObjectFactory>, InitializingBean

public class ObjectFactoryCreatingFactoryBean
extends AbstractFactoryBean<ObjectFactory>

A FactoryBean implementation that returns a value which is an ObjectFactory that in turn returns a bean sourced from a BeanFactory.

As such, this may be used to avoid having a client object directly calling BeanFactory.getBean(String) to get a (typically prototype) bean from a BeanFactory, which would be a violation of the inversion of control principle. Instead, with the use of this class, the client object can be fed an ObjectFactory instance as a property which directly returns only the one target bean (again, which is typically a prototype bean).

A sample config in an XML-based BeanFactory might look as follows:


   <!-- Prototype bean since we have state -->
   <bean id="myService" class="a.b.c.MyService" scope="prototype"/>

   <bean id="myServiceFactory"
     <property name="targetBeanName"><idref local="myService"/></property>

   <bean id="clientBean" class="a.b.c.MyClientBean">
     <property name="myServiceFactory" ref="myServiceFactory"/>


The attendant MyClientBean class implementation might look something like this:

package a.b.c;

 import org.springframework.beans.factory.ObjectFactory;

 public class MyClientBean {

   private ObjectFactory<MyService> myServiceFactory;

   public void setMyServiceFactory(ObjectFactory<MyService> myServiceFactory) {
     this.myServiceFactory = myServiceFactory;

   public void someBusinessMethod() {
     // get a 'fresh', brand new MyService instance
     MyService service = this.myServiceFactory.getObject();
     // use the service object to effect the business logic...

An alternate approach to this application of an object creational pattern would be to use the ServiceLocatorFactoryBean to source (prototype) beans. The ServiceLocatorFactoryBean approach has the advantage of the fact that one doesn't have to depend on any Spring-specific interface such as ObjectFactory, but has the disadvantage of requiring runtime class generation. Please do consult the ServiceLocatorFactoryBean JavaDoc for a fuller discussion of this issue.

Colin Sampaleanu, Juergen Hoeller
See Also:
ObjectFactory, ServiceLocatorFactoryBean

Nested Class Summary
private static class ObjectFactoryCreatingFactoryBean.TargetBeanObjectFactory
          Independent inner class - for serialization purposes.
Field Summary
private  java.lang.String targetBeanName
Fields inherited from class org.springframework.beans.factory.config.AbstractFactoryBean
Constructor Summary
Method Summary
 void afterPropertiesSet()
          Eagerly create the singleton instance, if necessary.
protected  ObjectFactory createInstance()
          Template method that subclasses must override to construct the object returned by this factory.
 java.lang.Class getObjectType()
          This abstract method declaration mirrors the method in the FactoryBean interface, for a consistent offering of abstract template methods.
 void setTargetBeanName(java.lang.String targetBeanName)
          Set the name of the target bean.
Methods inherited from class org.springframework.beans.factory.config.AbstractFactoryBean
destroy, destroyInstance, getBeanFactory, getBeanTypeConverter, getEarlySingletonInterfaces, getObject, isSingleton, setBeanClassLoader, setBeanFactory, setSingleton
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail


private java.lang.String targetBeanName
Constructor Detail


public ObjectFactoryCreatingFactoryBean()
Method Detail


public void setTargetBeanName(java.lang.String targetBeanName)
Set the name of the target bean.

The target does not have to be a non-singleton bean, but realisticially always will be (because if the target bean were a singleton, then said singleton bean could simply be injected straight into the dependent object, thus obviating the need for the extra level of indirection afforded by this factory approach).


public void afterPropertiesSet()
                        throws java.lang.Exception
Description copied from class: AbstractFactoryBean
Eagerly create the singleton instance, if necessary.

Specified by:
afterPropertiesSet in interface InitializingBean
afterPropertiesSet in class AbstractFactoryBean<ObjectFactory>
java.lang.Exception - in the event of misconfiguration (such as failure to set an essential property) or if initialization fails.


public java.lang.Class getObjectType()
Description copied from class: AbstractFactoryBean
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<ObjectFactory>
Specified by:
getObjectType in class AbstractFactoryBean<ObjectFactory>
the type of object that this FactoryBean creates, or null if not known at the time of the call
See Also:


protected ObjectFactory createInstance()
Description copied from class: AbstractFactoryBean
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 AbstractFactoryBean.getObject() call.

Specified by:
createInstance in class AbstractFactoryBean<ObjectFactory>
the object returned by this factory
See Also: