Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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

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:
  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`

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.
`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, setBeanFactory, 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.

### afterPropertiesSet

    public void afterPropertiesSet()
                            throws Exception

  Description copied from class: `AbstractFactoryBean`
  Eagerly create the singleton instance, if necessary.

  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 class: `AbstractFactoryBean`
  This abstract method declaration shadows the method in the FactoryBean interface. This is necessary to make the `getEarlySingletonInterfaces` implementation in this class work on Sun's JDK 1.3 classic VM, which can't find the method when executing `getEarlySingletonInterfaces` else.

  Specified by:
    `getObjectType` in interface `FactoryBean`
  Specified by:
    `getObjectType` in class `AbstractFactoryBean`
  Returns:
    the type of object that this FactoryBean creates, or `null` if not known at the time of the call
  See Also:
    `FactoryBean.getObjectType()`, `AbstractFactoryBean.getEarlySingletonInterfaces()`

### 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()`

### getTargetBean

    protected Object getTargetBean(String targetBeanName)

  Template method for obtaining a target bean instance. Called by the exposed ObjectFactory's `getObject()` method.

  Parameters:
    `targetBeanName` - the name of the target bean
  Returns:
    the target bean instance

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2002-2007 The Spring Framework.