org.springframework.beans.factory.config
Class ObjectFactoryCreatingFactoryBean

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

All Implemented Interfaces:

BeanFactoryAware, DisposableBean, FactoryBean, InitializingBean

public class ObjectFactoryCreatingFactoryBean
extends AbstractFactoryBean
implements BeanFactoryAware

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:

<beans>

   <!-- Prototype bean since we have state -->
   <bean id="myService" class="a.b.c.MyService" singleton="false"/>
 
   <bean id="myServiceFactory"
            class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
     <property name="targetBeanName"><idref local="myService"/></property>
   </bean> 
  
   <bean id="clientBean" class="a.b.c.MyClientBean">
     <property name="myServiceFactory" ref="myServiceFactory"/>
   </bean>

</beans>

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 myServiceFactory;
 
    public void setMyServiceFactory(ObjectFactory 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.

Since:

2004-05-11

Author:

Colin Sampaleanu

See Also:

ObjectFactory, ServiceLocatorFactoryBean

Field Summary

Fields inherited from class org.springframework.beans.factory.config.AbstractFactoryBean

logger

Constructor Summary

ObjectFactoryCreatingFactoryBean()

Method Summary

void	afterPropertiesSet() Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
protected Object	createInstance() Template method that subclasses must override to construct the object returned by this factory.
Class	getObjectType() Return the type of object that this FactoryBean creates, or null if not known in advance.
void	setBeanFactory(BeanFactory beanFactory) Callback that supplies the owning factory to a bean instance.
void	setTargetBeanName(String targetBeanName) Set the name of the target bean.

Methods inherited from class org.springframework.beans.factory.config.AbstractFactoryBean

destroy, destroyInstance, getObject, isSingleton, setSingleton

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ObjectFactoryCreatingFactoryBean

public ObjectFactoryCreatingFactoryBean()

Method Detail

setTargetBeanName

public void setTargetBeanName(String targetBeanName)

Set the name of the target bean.

The target does not have to be a prototype 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 the approach encapsulated by this class). Please note that no exception will be thrown if the supplied targetBeanName does not reference a prototype bean.

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 (may not be null). The bean can immediately call methods on the factory.

See Also:

BeanInitializationException

createInstance

protected Object 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

Returns:

the object returned by this factory

See Also:

AbstractFactoryBean.getObject()

afterPropertiesSet

public void afterPropertiesSet()
                        throws Exception

Description copied from interface: InitializingBean

Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).

This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.

Specified by:

afterPropertiesSet in interface InitializingBean

Overrides:

afterPropertiesSet in class AbstractFactoryBean

Throws:

Exception - in the event of misconfiguration (such as failure to set an essential property) or if initialization fails.

getObjectType

public Class getObjectType()

Description copied from interface: FactoryBean

Return the type of object that this FactoryBean creates, or null if not known in advance.

This allows one to check for specific types of beans without instantiating objects, for example on autowiring.

In the case of implementations that are creating a singleton object, this method should try to avoid singleton creation as far as possible; it should rather estimate the type in advance. For prototypes, returning a meaningful type here is advisable too.

This method can be called before this FactoryBean has been fully initialized. It must not rely on state created during initialization; of course, it can still use such state if available.

NOTE: Autowiring will simply ignore FactoryBeans that return null here. Therefore it is highly recommended to implement this method properly, using the current state of the FactoryBean.

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:

ListableBeanFactory.getBeansOfType(java.lang.Class)