public class MethodInvokingFactoryBean extends MethodInvokingBean implements FactoryBean<java.lang.Object>
FactoryBean
which 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
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.
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 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"/> </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>
MethodInvokingBean
,
MethodInvoker
Modifier and Type | Field and Description |
---|---|
private boolean |
initialized |
private boolean |
singleton |
private java.lang.Object |
singletonObject
Method call result in the singleton case
|
Constructor and Description |
---|
MethodInvokingFactoryBean() |
Modifier and Type | Method and Description |
---|---|
void |
afterPropertiesSet()
Invoked by a BeanFactory after it has set all bean properties supplied
(and satisfied BeanFactoryAware and ApplicationContextAware).
|
java.lang.Object |
getObject()
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.
|
java.lang.Class<?> |
getObjectType()
Return the type of object that this FactoryBean creates,
or
null if not known in advance. |
boolean |
isSingleton()
Is the object managed by this factory a singleton? That is,
will
FactoryBean.getObject() always return the same object
(a reference that can be cached)? |
void |
setSingleton(boolean singleton)
Set if a singleton should be created, or a new object on each
getObject() request otherwise. |
getDefaultTypeConverter, invokeWithTargetException, resolveClassName, setBeanClassLoader, setBeanFactory
doFindMatchingMethod, findMatchingMethod, getTypeConverter, registerCustomEditor, setTypeConverter
getArguments, getPreparedMethod, getTargetClass, getTargetMethod, getTargetObject, getTypeDifferenceWeight, invoke, isPrepared, prepare, setArguments, setStaticMethod, setTargetClass, setTargetMethod, setTargetObject
private boolean singleton
private boolean initialized
private java.lang.Object singletonObject
public void setSingleton(boolean singleton)
getObject()
request otherwise. Default is "true".public void afterPropertiesSet() throws java.lang.Exception
InitializingBean
This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.
afterPropertiesSet
in interface InitializingBean
afterPropertiesSet
in class MethodInvokingBean
java.lang.Exception
- in the event of misconfiguration (such
as failure to set an essential property) or if initialization fails.public java.lang.Object getObject() throws java.lang.Exception
getObject
in interface FactoryBean<java.lang.Object>
null
)java.lang.Exception
- in case of creation errorsFactoryBeanNotInitializedException
public java.lang.Class<?> getObjectType()
null
if not known in advance.getObjectType
in interface FactoryBean<java.lang.Object>
null
if not known at the time of the callListableBeanFactory.getBeansOfType(java.lang.Class<T>)
public boolean isSingleton()
FactoryBean
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 true
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 SmartFactoryBean
interface
may explicitly indicate independent instances through its
SmartFactoryBean.isPrototype()
method. Plain FactoryBean
implementations which do not implement this extended interface are
simply assumed to always return independent instances if the
isSingleton()
implementation returns false
.
The default implementation returns true
, since a
FactoryBean
typically manages a singleton instance.
isSingleton
in interface FactoryBean<java.lang.Object>
FactoryBean.getObject()
,
SmartFactoryBean.isPrototype()