org.springframework.util

## Class MethodInvoker

- java.lang.Object
- - org.springframework.util.MethodInvoker

Direct Known Subclasses:
  ArgumentConvertingMethodInvoker

    public class MethodInvoker
    extends Object

Helper class that allows for specifying a method to invoke in a declarative fashion, be it static or non-static.

Usage: Specify "targetClass"/"targetMethod" or "targetObject"/"targetMethod", optionally specify arguments, prepare the invoker. Afterwards, you may invoke the method any number of times, obtaining the invocation result.

Typically not used directly but via its subclasses `MethodInvokingFactoryBean` and `MethodInvokingJobDetailFactoryBean`.

Since:
  19.02.2004
Author:
  Colin Sampaleanu, Juergen Hoeller
See Also:
  `prepare()`, `invoke()`

### Constructor Summary

Constructors
Constructor and Description
`MethodInvoker()`

### Method Summary

Methods
`protected Method` `findMatchingMethod()` Find a matching method with the specified name for the specified arguments.
`Object[]` `getArguments()` Return the arguments for the method invocation.
`Method` `getPreparedMethod()` Return the prepared Method object that will be invoked.
`Class` `getTargetClass()` Return the target class on which to call the target method.
`String` `getTargetMethod()` Return the name of the method to be invoked.
`Object` `getTargetObject()` Return the target object on which to call the target method.
`static int` `getTypeDifferenceWeight(Class[] paramTypes, Object[] args)` Algorithm that judges the match between the declared parameter types of a candidate method and a specific list of arguments that this method is supposed to be invoked with.
`Object` `invoke()` Invoke the specified method.
`boolean` `isPrepared()` Return whether this invoker has been prepared already, i.e.
`void` `prepare()` Prepare the specified method.
`protected Class` `resolveClassName(String className)` Resolve the given class name into a Class.
`void` `setArguments(Object[] arguments)` Set arguments for the method invocation.
`void` `setStaticMethod(String staticMethod)` Set a fully qualified static method name to invoke, e.g.
`void` `setTargetClass(Class targetClass)` Set the target class on which to call the target method.
`void` `setTargetMethod(String targetMethod)` Set the name of the method to be invoked.
`void` `setTargetObject(Object targetObject)` Set the target object on which to call the target method.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### MethodInvoker

    public MethodInvoker()

### Method Detail

#### setTargetClass

    public void setTargetClass(Class targetClass)

Set the target class on which to call the target method. Only necessary when the target method is static; else, a target object needs to be specified anyway.

See Also:
  `setTargetObject(java.lang.Object)`, `setTargetMethod(java.lang.String)`

#### getTargetClass

    public Class getTargetClass()

Return the target class on which to call the target method.

#### setTargetObject

    public void setTargetObject(Object targetObject)

Set the target object on which to call the target method. Only necessary when the target method is not static; else, a target class is sufficient.

See Also:
  `setTargetClass(java.lang.Class)`, `setTargetMethod(java.lang.String)`

#### getTargetObject

    public Object getTargetObject()

Return the target object on which to call the target method.

#### setTargetMethod

    public void setTargetMethod(String targetMethod)

Set the name of the method to be invoked. Refers to either a static method or a non-static method, depending on a target object being set.

See Also:
  `setTargetClass(java.lang.Class)`, `setTargetObject(java.lang.Object)`

#### getTargetMethod

    public String getTargetMethod()

Return the name of the method to be invoked.

#### setStaticMethod

    public void setStaticMethod(String staticMethod)

Set a fully qualified static method name to invoke, e.g. "example.MyExampleClass.myExampleMethod". Convenient alternative to specifying targetClass and targetMethod.

See Also:
  `setTargetClass(java.lang.Class)`, `setTargetMethod(java.lang.String)`

#### setArguments

    public void setArguments(Object[] arguments)

Set arguments for the method invocation. If this property is not set, or the Object array is of length 0, a method with no arguments is assumed.

#### getArguments

    public Object[] getArguments()

Return the arguments for the method invocation.

#### prepare

    public void prepare()
                 throws ClassNotFoundException,
                        NoSuchMethodException

Prepare the specified method. The method can be invoked any number of times afterwards.

Throws:
  `ClassNotFoundException`
  `NoSuchMethodException`
See Also:
  `getPreparedMethod()`, `invoke()`

#### resolveClassName

    protected Class resolveClassName(String className)
                              throws ClassNotFoundException

Resolve the given class name into a Class.

The default implementations uses `ClassUtils.forName`, using the thread context class loader.

Parameters:
  `className` - the class name to resolve
Returns:
  the resolved Class
Throws:
  `ClassNotFoundException` - if the class name was invalid

#### findMatchingMethod

    protected Method findMatchingMethod()

Find a matching method with the specified name for the specified arguments.

Returns:
  a matching method, or `null` if none
See Also:
  `getTargetClass()`, `getTargetMethod()`, `getArguments()`

#### getPreparedMethod

    public Method getPreparedMethod()
                             throws IllegalStateException

Return the prepared Method object that will be invoked.

Can for example be used to determine the return type.

Returns:
  the prepared Method object (never `null`)
Throws:
  `IllegalStateException` - if the invoker hasn't been prepared yet
See Also:
  `prepare()`, `invoke()`

#### isPrepared

    public boolean isPrepared()

Return whether this invoker has been prepared already, i.e. whether it allows access to `getPreparedMethod()` already.

#### invoke

    public Object invoke()
                  throws InvocationTargetException,
                         IllegalAccessException

Invoke the specified method.

The invoker needs to have been prepared before.

Returns:
  the object (possibly null) returned by the method invocation, or `null` if the method has a void return type
Throws:
  `InvocationTargetException` - if the target method threw an exception
  `IllegalAccessException` - if the target method couldn't be accessed
See Also:
  `prepare()`

#### getTypeDifferenceWeight

    public static int getTypeDifferenceWeight(Class[] paramTypes,
                              Object[] args)

Algorithm that judges the match between the declared parameter types of a candidate method and a specific list of arguments that this method is supposed to be invoked with.

Determines a weight that represents the class hierarchy difference between types and arguments. A direct match, i.e. type Integer -> arg of class Integer, does not increase the result - all direct matches means weight 0. A match between type Object and arg of class Integer would increase the weight by 2, due to the superclass 2 steps up in the hierarchy (i.e. Object) being the last one that still matches the required type Object. Type Number and class Integer would increase the weight by 1 accordingly, due to the superclass 1 step up the hierarchy (i.e. Number) still matching the required type Number. Therefore, with an arg of type Integer, a constructor (Integer) would be preferred to a constructor (Number) which would in turn be preferred to a constructor (Object). All argument weights get accumulated.

Parameters:
  `paramTypes` - the parameter types to match
  `args` - the arguments to match
Returns:
  the accumulated weight for all arguments