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
    Modifier and Type | Method and Description
    --- | ---
    `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