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

org.springframework.expression.spel.support

## Class ReflectiveMethodResolver

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

- All Implemented Interfaces:
    MethodResolver

      public class ReflectiveMethodResolver
      extends Object
      implements MethodResolver

  Reflection-based `MethodResolver` used by default in `StandardEvaluationContext` unless explicit method resolvers have been specified.
  Since:
    3.0
  Author:
    Andy Clement, Juergen Hoeller, Chris Beams
  See Also:
    `StandardEvaluationContext.addMethodResolver(MethodResolver)`

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ReflectiveMethodResolver()`
    `ReflectiveMethodResolver(boolean useDistance)` This constructors allows the ReflectiveMethodResolver to be configured such that it will use a distance computation to check which is the better of two close matches (when there are multiple matches).

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected Method[]` | `getMethods(Class<?> type)` Return the set of methods for this type.
    `void` | `registerMethodFilter(Class<?> type, MethodFilter filter)`
    `MethodExecutor` | `resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes)` Locate a method on a type.

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

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

- - ### Constructor Detail

    - #### ReflectiveMethodResolver

          public ReflectiveMethodResolver()

    - #### ReflectiveMethodResolver

          public ReflectiveMethodResolver(boolean useDistance)

      This constructors allows the ReflectiveMethodResolver to be configured such that it will use a distance computation to check which is the better of two close matches (when there are multiple matches). Using the distance computation is intended to ensure matches are more closely representative of what a Java compiler would do when taking into account boxing/unboxing and whether the method candidates are declared to handle a supertype of the type (of the argument) being passed in.
      Parameters:
        `useDistance` - true if distance computation should be used when calculating matches

  - ### Method Detail

    - #### resolve

          public MethodExecutor resolve(EvaluationContext context,
                               Object targetObject,
                               String name,
                               List<TypeDescriptor> argumentTypes)
                                 throws AccessException

      Locate a method on a type. There are three kinds of match that might occur:
      1. An exact match where the types of the arguments match the types of the constructor
      2. An in-exact match where the types we are looking for are subtypes of those defined on the constructor
      3. A match where we are able to convert the arguments into those expected by the constructor, according to the registered type converter.
      Specified by:
        `resolve` in interface `MethodResolver`
      Parameters:
        `context` - the current evaluation context
        `targetObject` - the object upon which the method is being called
        `argumentTypes` - the arguments that the constructor must be able to handle
      Returns:
        a MethodExecutor that can invoke the method, or null if the method cannot be found
      Throws:
        `AccessException`

    - #### registerMethodFilter

          public void registerMethodFilter(Class<?> type,
                                  MethodFilter filter)

    - #### getMethods

          protected Method[] getMethods(Class<?> type)

      Return the set of methods for this type. The default implementation returns the result of Class#getMethods for the given `type`, but subclasses may override in order to alter the results, e.g. specifying static methods declared elsewhere.
      Parameters:
        `type` - the class for which to return the methods
      Since:
        3.1.1