Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The 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 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()`, `MethodInvokingFactoryBean`, `MethodInvokingJobDetailFactoryBean`

Constructor Summary
`MethodInvoker()`

Method Summary
`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. whether it allows access to `getPreparedMethod()` already.
`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

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

Copyright © 2002-2008 The Spring Framework.