| 
 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectorg.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 mirrors the method in the FactoryBean interface, for a consistent offering of abstract template methods. | 
| protected  Object | getTargetBean(String targetBeanName)Template method for obtaining a target 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, setBeanClassLoader, setBeanFactory, 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 afterPropertiesSet()
                        throws Exception
AbstractFactoryBean
afterPropertiesSet in interface InitializingBeanafterPropertiesSet in class AbstractFactoryBeanException - in the event of misconfiguration (such
 as failure to set an essential property) or if initialization fails.public Class getObjectType()
AbstractFactoryBean
getObjectType in interface FactoryBeangetObjectType in class AbstractFactoryBeannull if not known at the time of the callFactoryBean.getObjectType()protected Object createInstance()
AbstractFactoryBeanInvoked on initialization of this FactoryBean in case of
 a singleton; else, on each AbstractFactoryBean.getObject() call.
createInstance in class AbstractFactoryBeanAbstractFactoryBean.getObject()protected Object getTargetBean(String targetBeanName)
getObject() method.
targetBeanName - the name of the target bean
| 
 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||