Package org.springframework.expression.spel.support

# Class ReflectionHelper

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

public abstract 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, Sam Brannen

## Constructor Summary

Constructors
Constructor
Description
`ReflectionHelper()`

## Method Summary

Modifier and Type
Method
Description
`static boolean`
`convertAllArguments(TypeConverter converter, Object[] arguments, Method method)`
Convert the supplied set of arguments into the parameter types of the supplied `Method`.
`static boolean`
`convertAllMethodHandleArguments(TypeConverter converter, Object[] arguments, MethodHandle methodHandle, Integer varargsPosition)`
Convert the supplied set of arguments into the parameter types of the supplied `MethodHandle`, taking the varargs position into account.
`static int`
`getTypeDifferenceWeight(List<org.springframework.core.convert.TypeDescriptor> paramTypes, List<org.springframework.core.convert.TypeDescriptor> argTypes)`
Based on `MethodInvoker.getTypeDifferenceWeight(Class[], Object[])` but operates on TypeDescriptors.
`static Object[]`
`setupArgumentsForVarargsInvocation(Class<?>[] requiredParameterTypes, Object... args)`
Package up the supplied `args` so that they correctly match what is expected in `requiredParameterTypes`.

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

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

## Constructor Details

### ReflectionHelper

public ReflectionHelper()

## Method Details

### getTypeDifferenceWeight

public static int getTypeDifferenceWeight(List<org.springframework.core.convert.TypeDescriptor> paramTypes, List<org.springframework.core.convert.TypeDescriptor> argTypes)
Based on `MethodInvoker.getTypeDifferenceWeight(Class[], Object[])` but operates on TypeDescriptors.

### convertAllArguments

public static boolean convertAllArguments(TypeConverter converter, Object[] arguments, Method method) throws SpelEvaluationException
Convert the supplied set of arguments into the parameter types of the supplied `Method`.

If the supplied method is a varargs method, the final parameter type must be an array whose component type should be used as the conversion target for extraneous arguments. For example, if the parameter types are `{Integer, String[]}` and the input arguments are `{Integer, boolean, float}`, then both the `boolean` and the `float` must be converted to strings.

This method does not repackage the arguments into a form suitable for the varargs invocation: a subsequent call to `setupArgumentsForVarargsInvocation(Class[], Object...)` is required for that.

Parameters:
  `converter` - the converter to use for type conversions
  `arguments` - the arguments to convert to the required parameter types
  `method` - the target `Method`
Returns:
  `true` if some kind of conversion occurred on an argument
Throws:
  `SpelEvaluationException` - if a problem occurs during conversion

### convertAllMethodHandleArguments

public static boolean convertAllMethodHandleArguments(TypeConverter converter, Object[] arguments, MethodHandle methodHandle, @Nullable Integer varargsPosition) throws EvaluationException
Convert the supplied set of arguments into the parameter types of the supplied `MethodHandle`, taking the varargs position into account.

The arguments are converted 'in-place' in the input array.

Parameters:
  `converter` - the converter to use for type conversions
  `arguments` - the arguments to convert to the required parameter types
  `methodHandle` - the target `MethodHandle`
  `varargsPosition` - the known position of the varargs argument, if any (`null` if not varargs)
Returns:
  `true` if some kind of conversion occurred on an argument
Throws:
  `EvaluationException` - if a problem occurs during conversion
Since:
  6.1

### setupArgumentsForVarargsInvocation

public static Object[] setupArgumentsForVarargsInvocation(Class<?>[] requiredParameterTypes, Object... args)
Package up the supplied `args` so that they correctly match what is expected in `requiredParameterTypes`.

For example, if `requiredParameterTypes` is `(int, String[])` because the second parameter was declared as `String...`, then if `args` is `[1, "a", "b"]` it must be repackaged as `[1, new String[] {"a", "b"}]` in order to match the expected types.

Parameters:
  `requiredParameterTypes` - the types of the parameters for the invocation
  `args` - the arguments to be set up for the invocation
Returns:
  a repackaged array of arguments where any varargs setup has been performed