|
The Spring Framework | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object org.springframework.beans.factory.config.AbstractFactoryBean org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean
public class ObjectFactoryCreatingFactoryBean
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.
ObjectFactory
,
ServiceLocatorFactoryBean
Field Summary |
---|
Fields inherited from class org.springframework.beans.factory.config.AbstractFactoryBean |
---|
logger |
Constructor Summary | |
---|---|
ObjectFactoryCreatingFactoryBean()
|
Method Summary | |
---|---|
void |
afterPropertiesSet()
Eagerly create the singleton instance, if necessary. |
protected Object |
createInstance()
Template method that subclasses must override to construct the object returned by this factory. |
Class |
getObjectType()
This abstract method declaration shadows the method in the FactoryBean interface. |
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, getBeanFactory, getBeanTypeConverter, getEarlySingletonInterfaces, getObject, isSingleton, setSingleton |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Constructor Detail |
---|
public ObjectFactoryCreatingFactoryBean()
Method Detail |
---|
public void setTargetBeanName(String targetBeanName)
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.
public void setBeanFactory(BeanFactory beanFactory)
BeanFactoryAware
Invoked after the population of normal bean properties
but before an initialization callback such as
InitializingBean.afterPropertiesSet()
or a custom init-method.
setBeanFactory
in interface BeanFactoryAware
setBeanFactory
in class AbstractFactoryBean
beanFactory
- owning BeanFactory (never null
).
The bean can immediately call methods on the factory.BeanInitializationException
protected Object createInstance()
AbstractFactoryBean
Invoked on initialization of this FactoryBean in case of
a singleton; else, on each AbstractFactoryBean.getObject()
call.
createInstance
in class AbstractFactoryBean
AbstractFactoryBean.getObject()
public void afterPropertiesSet() throws Exception
AbstractFactoryBean
afterPropertiesSet
in interface InitializingBean
afterPropertiesSet
in class AbstractFactoryBean
Exception
- in the event of misconfiguration (such
as failure to set an essential property) or if initialization fails.public Class getObjectType()
AbstractFactoryBean
getEarlySingletonInterfaces
implementation
in this class work on Sun's JDK 1.3 classic VM, which can't find the method
when executing getEarlySingletonInterfaces
else.
getObjectType
in interface FactoryBean
getObjectType
in class AbstractFactoryBean
null
if not known at the time of the callFactoryBean.getObjectType()
,
AbstractFactoryBean.getEarlySingletonInterfaces()
|
The Spring Framework | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |