Overview | Package | Class | Tree | Deprecated | Index | Help
| Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.util
Class MethodInvoker

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

Direct Known Subclasses:
  ArgumentConvertingMethodInvoker

    public class MethodInvoker

extends java.lang.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
`MethodInvoker()`

Method Summary
`protected java.lang.reflect.Method` | `findMatchingMethod()` Find a matching method with the specified name for the specified arguments.
`java.lang.Object[]` | `getArguments()` Return the arguments for the method invocation.
`java.lang.reflect.Method` | `getPreparedMethod()` Return the prepared Method object that will be invoked.
`java.lang.Class` | `getTargetClass()` Return the target class on which to call the target method.
`java.lang.String` | `getTargetMethod()` Return the name of the method to be invoked.
`java.lang.Object` | `getTargetObject()` Return the target object on which to call the target method.
`static int` | `getTypeDifferenceWeight(java.lang.Class[] paramTypes, java.lang.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.
`java.lang.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 java.lang.Class` | `resolveClassName(java.lang.String className)` Resolve the given class name into a Class.
`void` | `setArguments(java.lang.Object[] arguments)` Set arguments for the method invocation.
`void` | `setStaticMethod(java.lang.String staticMethod)` Set a fully qualified static method name to invoke, e.g.
`void` | `setTargetClass(java.lang.Class targetClass)` Set the target class on which to call the target method.
`void` | `setTargetMethod(java.lang.String targetMethod)` Set the name of the method to be invoked.
`void` | `setTargetObject(java.lang.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(java.lang.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 java.lang.Class getTargetClass()

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

### setTargetObject

    public void setTargetObject(java.lang.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 java.lang.Object getTargetObject()

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

### setTargetMethod

    public void setTargetMethod(java.lang.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 java.lang.String getTargetMethod()

  Return the name of the method to be invoked.

### setStaticMethod

    public void setStaticMethod(java.lang.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(java.lang.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 java.lang.Object[] getArguments()

  Return the arguments for the method invocation.

### prepare

    public void prepare()
                 throws java.lang.ClassNotFoundException,
                        java.lang.NoSuchMethodException

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

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

### resolveClassName

    protected java.lang.Class resolveClassName(java.lang.String className)
                                        throws java.lang.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:
    `java.lang.ClassNotFoundException` - if the class name was invalid

### findMatchingMethod

    protected java.lang.reflect.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 java.lang.reflect.Method getPreparedMethod()
                                               throws java.lang.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:
    `java.lang.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 java.lang.Object invoke()
                            throws java.lang.reflect.InvocationTargetException,
                                   java.lang.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:
    `java.lang.reflect.InvocationTargetException` - if the target method threw an exception
    `java.lang.IllegalAccessException` - if the target method couldn't be accessed
  See Also:
    `prepare()`

### getTypeDifferenceWeight

    public static int getTypeDifferenceWeight(java.lang.Class[] paramTypes,
                                              java.lang.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

Overview | Package | Class | Tree | Deprecated | Index | Help
| Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD