java.lang.Object
   org.springframework.util.MethodInvoker
      org.springframework.beans.support.ArgumentConvertingMethodInvoker
         org.springframework.beans.factory.config.MethodInvokingFactoryBean

All Implemented Interfaces:
    BeanClassLoaderAware, BeanFactoryAware, InitializingBean, FactoryBean

Note that as it is expected to be used mostly for accessing factory methods, this factory by default operates in a singleton fashion. The first request to #getObject by the owning bean factory will cause a method invocation, whose return value will be cached for subsequent requests. An internal singleton property may be set to "false", to cause this factory to invoke the target method each time it is asked for an object.

A static target method may be specified by setting the targetMethod property to a String representing the static method name, with targetClass specifying the Class that the static method is defined on. Alternatively, a target instance method may be specified, by setting the targetObject property as the target object, and the targetMethod property as the name of the method to call on that target object. Arguments for the method invocation may be specified by setting the arguments property.

This class depends on #afterPropertiesSet() being called once all properties have been set, as per the InitializingBean contract.

An example (in an XML based bean factory definition) of a bean definition which uses this class to call a static factory method:

<bean id="myObject" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="staticMethod"><value>com.whatever.MyClassFactory.getInstance</value></property>
</bean>

An example of calling a static method then an instance method to get at a Java system property. Somewhat verbose, but it works.

<bean id="sysProps" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetClass"><value>java.lang.System</value></property>
<property name="targetMethod"><value>getProperties</value></property>
</bean>

<bean id="javaVersion" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject"><ref local="sysProps"/></property>
<property name="targetMethod"><value>getProperty</value></property>
<property name="arguments">
<list>
<value>java.version</value>
</list>
</property>
</bean>

author: Colin - Sampaleanu

author: Juergen - Hoeller

since: 21.11.2003 -

 public  void afterPropertiesSet() throws Exception 
{
		prepare();
		if (this.singleton) {
			this.initialized = true;
			this.singletonObject = doInvoke();
		}
}

 protected TypeConverter getDefaultTypeConverter() 
{
		if (this.beanFactory != null) {
			return this.beanFactory.getTypeConverter();
		}
		else {
			return super.getDefaultTypeConverter();
		}
}

 public Object getObject() throws Exception 
{
		if (this.singleton) {
			if (!this.initialized) {
				throw new FactoryBeanNotInitializedException();
			}
			// Singleton: return shared object.
			return this.singletonObject;
		}
		else {
			// Prototype: new object on each call.
			return doInvoke();
		}
}

 public Class getObjectType() 
{
		if (!isPrepared()) {
			// Not fully initialized yet - > return null to indicate "not known yet".
			return null;
		}
		return getPreparedMethod().getReturnType();
}

 public boolean isSingleton() 
{
		return this.singleton;
}

 protected Class resolveClassName(String className) throws ClassNotFoundException 
{
		return ClassUtils.forName(className, this.beanClassLoader);
}

 public  void setBeanClassLoader(ClassLoader classLoader) 
{
		this.beanClassLoader = classLoader;
}

 public  void setBeanFactory(BeanFactory beanFactory) 
{
		if (beanFactory instanceof ConfigurableBeanFactory) {
			this.beanFactory = (ConfigurableBeanFactory) beanFactory;
		}
}

 public  void setSingleton(boolean singleton) 
{
	                  	 
		this.singleton = singleton;
}