public class MethodInvokingFactoryBean extends MethodInvokingBean implements FactoryBean<java.lang.Object>
FactoryBeanwhich returns a value which is the result of a static or instance method invocation. For most use cases it is better to just use the container's built-in factory method support for the same purpose, since that is smarter at converting arguments. This factory bean is still useful though when you need to call a method which doesn't return any value (for example, a static class method to force some sort of initialization to happen). This use case is not supported by factory methods, since a return value is needed to obtain the bean instance.
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
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.
NOTE: If your target method does not produce a result to expose, consider
MethodInvokingBean instead, which avoids the type determination and
lifecycle limitations that this
MethodInvokingFactoryBean comes with.
This invoker supports any kind of target method. A static 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
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"/> </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"/> <property name="targetMethod" value="getProperties"/> </bean> <bean id="javaVersion" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean"> <property name="targetObject" ref="sysProps"/> <property name="targetMethod" value="getProperty"/> <property name="arguments" value="java.version"/> </bean>
|Constructor and Description|
|Modifier and Type||Method and Description|
Invoked by the containing
Returns the same value each time if the singleton property is set to "true", otherwise returns the value returned from invoking the specified method on the fly.
Return the type of object that this FactoryBean creates, or
Is the object managed by this factory a singleton? That is, will
Set if a singleton should be created, or a new object on each
getDefaultTypeConverter, invokeWithTargetException, resolveClassName, setBeanClassLoader, setBeanFactory
doFindMatchingMethod, findMatchingMethod, getTypeConverter, registerCustomEditor, setTypeConverter
getArguments, getPreparedMethod, getTargetClass, getTargetMethod, getTargetObject, getTypeDifferenceWeight, invoke, isPrepared, prepare, setArguments, setStaticMethod, setTargetClass, setTargetMethod, setTargetObject
public void setSingleton(boolean singleton)
getObject()request otherwise. Default is "true".
public void afterPropertiesSet() throws java.lang.Exception
BeanFactoryafter it has set all bean properties and satisfied
This method allows the bean instance to perform validation of its overall configuration and final initialization when all bean properties have been set.
@Nullable public java.lang.Object getObject() throws java.lang.Exception
public java.lang.Class<?> getObjectType()
nullif not known in advance.
nullif not known at the time of the call
public boolean isSingleton()
FactoryBean.getObject()always return the same object (a reference that can be cached)?
NOTE: If a FactoryBean indicates to hold a singleton object,
the object returned from
getObject() might get cached
by the owning BeanFactory. Hence, do not return
unless the FactoryBean always exposes the same reference.
The singleton status of the FactoryBean itself will generally be provided by the owning BeanFactory; usually, it has to be defined as singleton there.
NOTE: This method returning
false does not
necessarily indicate that returned objects are independent instances.
An implementation of the extended
may explicitly indicate independent instances through its
SmartFactoryBean.isPrototype() method. Plain
implementations which do not implement this extended interface are
simply assumed to always return independent instances if the
isSingleton() implementation returns
The default implementation returns
true, since a
FactoryBean typically manages a singleton instance.