ReflectionHelper (Spring Framework 3.2.1.RELEASE API)
Date: 2013-01-24

org.springframework.expression.spel.support

## Class ReflectionHelper

- java.lang.Object
- - org.springframework.expression.spel.support.ReflectionHelper

-     public class ReflectionHelper
      extends Object

  Utility methods used by the reflection resolver code to discover the appropriate methods/constructors and fields that should be used in expressions.
  Since:
    3.0
  Author:
    Andy Clement, Juergen Hoeller

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `ReflectionHelper.ArgsMatchKind`
    `static class` | `ReflectionHelper.ArgumentsMatchInfo` An instance of ArgumentsMatchInfo describes what kind of match was achieved between two sets of arguments - the set that a method/constructor is expecting and the set that are being supplied at the point of invocation.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ReflectionHelper()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static void` | `convertAllArguments(TypeConverter converter, Object[] arguments, Method method)` Convert a supplied set of arguments into the requested types.
    `static int` | `getTypeDifferenceWeight(List<TypeDescriptor> paramTypes, List<TypeDescriptor> argTypes)` Based on `MethodInvoker.getTypeDifferenceWeight(Class[], Object[])` but operates on TypeDescriptors.
    `static Object[]` | `setupArgumentsForVarargsInvocation(Class[] requiredParameterTypes, Object... args)` Package up the arguments so that they correctly match what is expected in parameterTypes.

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

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

- - ### Constructor Detail

    - #### ReflectionHelper

          public ReflectionHelper()

  - ### Method Detail

    - #### getTypeDifferenceWeight

          public static int getTypeDifferenceWeight(List<TypeDescriptor> paramTypes,
                                    List<TypeDescriptor> argTypes)

      Based on `MethodInvoker.getTypeDifferenceWeight(Class[], Object[])` but operates on TypeDescriptors.

    - #### convertAllArguments

          public static void convertAllArguments(TypeConverter converter,
                                 Object[] arguments,
                                 Method method)
                                          throws SpelEvaluationException

      Convert a supplied set of arguments into the requested types. If the parameterTypes are related to a varargs method then the final entry in the parameterTypes array is going to be an array itself whose component type should be used as the conversion target for extraneous arguments. (For example, if the parameterTypes are {Integer, String[]} and the input arguments are {Integer, boolean, float} then both the boolean and float must be converted to strings). This method does not repackage the arguments into a form suitable for the varargs invocation
      Parameters:
        `converter` - the converter to use for type conversions
        `arguments` - the arguments to convert to the requested parameter types
        `method` - the target Method
      Throws:
        `SpelEvaluationException` - if there is a problem with conversion

    - #### setupArgumentsForVarargsInvocation

          public static Object[] setupArgumentsForVarargsInvocation(Class[] requiredParameterTypes,
                                                    Object... args)

      Package up the arguments so that they correctly match what is expected in parameterTypes. For example, if parameterTypes is (int, String[]) because the second parameter was declared String... then if arguments is [1,"a","b"] then it must be repackaged as [1,new String[]{"a","b"}] in order to match the expected parameterTypes.
      Parameters:
        `requiredParameterTypes` - the types of the parameters for the invocation
        `args` - the arguments to be setup ready for the invocation
      Returns:
        a repackaged array of arguments where any varargs setup has been done