Class ObjectFactoryCreatingFactoryBean
- java.lang.Object
- org.springframework.beans.factory.config.AbstractFactoryBean<ObjectFactory<Object>>
- org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean
- All Implemented Interfaces:
Aware
,BeanClassLoaderAware
,BeanFactoryAware
,DisposableBean
,FactoryBean<ObjectFactory<Object>>
,InitializingBean
public class ObjectFactoryCreatingFactoryBean extends AbstractFactoryBean<ObjectFactory<Object>>
AFactoryBean
implementation that returns a value which is anObjectFactory
that in turn returns a bean sourced from aBeanFactory
.As such, this may be used to avoid having a client object directly calling
BeanFactory.getBean(String)
to get a (typically prototype) bean from aBeanFactory
, which would be a violation of the inversion of control principle. Instead, with the use of this class, the client object can be fed anObjectFactory
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" scope="prototype"/> <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<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. TheServiceLocatorFactoryBean
approach has the advantage of the fact that one doesn't have to depend on any Spring-specific interface such asObjectFactory
, but has the disadvantage of requiring runtime class generation. Please do consult theServiceLocatorFactoryBean JavaDoc
for a fuller discussion of this issue.- Since:
- 1.0.2
- Author:
- Colin Sampaleanu, Juergen Hoeller
- See Also:
ObjectFactory
,ServiceLocatorFactoryBean
Field Summary
Fields inherited from class org.springframework.beans.factory.config.AbstractFactoryBean
logger
Fields inherited from interface org.springframework.beans.factory.FactoryBean
OBJECT_TYPE_ATTRIBUTE
Constructor Summary
Constructors Constructor Description ObjectFactoryCreatingFactoryBean()
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description void
afterPropertiesSet()
Eagerly create the singleton instance, if necessary.protected ObjectFactory<Object>
createInstance()
Template method that subclasses must override to construct the object returned by this factory.Class<?>
getObjectType()
This abstract method declaration mirrors the method in the FactoryBean interface, for a consistent offering of abstract template methods.void
setTargetBeanName(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
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 non-singleton bean, but realistically 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).
afterPropertiesSet
public void afterPropertiesSet() throws Exception
Description copied from class:AbstractFactoryBean
Eagerly create the singleton instance, if necessary.- Specified by:
afterPropertiesSet
in interfaceInitializingBean
- Overrides:
afterPropertiesSet
in classAbstractFactoryBean<ObjectFactory<Object>>
- Throws:
Exception
- in the event of misconfiguration (such as failure to set an essential property) or if initialization fails for any other reason
getObjectType
public 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 interfaceFactoryBean<ObjectFactory<Object>>
- Specified by:
getObjectType
in classAbstractFactoryBean<ObjectFactory<Object>>
- 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 ObjectFactory<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 classAbstractFactoryBean<ObjectFactory<Object>>
- Returns:
- the object returned by this factory
- See Also:
AbstractFactoryBean.getObject()