Package org.springframework.core

Class MethodParameter

java.lang.Object
org.springframework.core.MethodParameter
Direct Known Subclasses:
SynthesizingMethodParameter
public class MethodParameter extends Object
Helper class that encapsulates the specification of a method parameter, i.e. a Method or Constructor plus a parameter index and a nested type index for a declared generic type. Useful as a specification object to pass along.

As of 4.2, there is a SynthesizingMethodParameter subclass available which synthesizes annotations with attribute aliases. That subclass is used for web and message endpoint processing, in particular.

Since:
2.0
Author:
Juergen Hoeller, Rob Harrop, Andy Clement, Sam Brannen, Sebastien Deleuze, Phillip Webb
See Also:

  • Constructor Details

    • MethodParameter

      public MethodParameter(Method method, int parameterIndex)
      Create a new MethodParameter for the given method, with nesting level 1.
      Parameters:
      method - the Method to specify a parameter for
      parameterIndex - the index of the parameter: -1 for the method return type; 0 for the first method parameter; 1 for the second method parameter, etc.

    • MethodParameter

      public MethodParameter(Method method, int parameterIndex, int nestingLevel)
      Create a new MethodParameter for the given method.
      Parameters:
      method - the Method to specify a parameter for
      parameterIndex - the index of the parameter: -1 for the method return type; 0 for the first method parameter; 1 for the second method parameter, etc.
      nestingLevel - the nesting level of the target type (typically 1; e.g. in case of a List of Lists, 1 would indicate the nested List, whereas 2 would indicate the element of the nested List)

    • MethodParameter

      public MethodParameter(Constructor<?> constructor, int parameterIndex)
      Create a new MethodParameter for the given constructor, with nesting level 1.
      Parameters:
      constructor - the Constructor to specify a parameter for
      parameterIndex - the index of the parameter

    • MethodParameter

      public MethodParameter(Constructor<?> constructor, int parameterIndex, int nestingLevel)
      Create a new MethodParameter for the given constructor.
      Parameters:
      constructor - the Constructor to specify a parameter for
      parameterIndex - the index of the parameter
      nestingLevel - the nesting level of the target type (typically 1; e.g. in case of a List of Lists, 1 would indicate the nested List, whereas 2 would indicate the element of the nested List)

    • MethodParameter

      public MethodParameter(MethodParameter original)
      Copy constructor, resulting in an independent MethodParameter object based on the same metadata and cache state that the original object was in.
      Parameters:
      original - the original MethodParameter object to copy from

  • Method Details

    • getMethod

      @Nullable public Method getMethod()
      Return the wrapped Method, if any.

      Note: Either Method or Constructor is available.

      Returns:
      the Method, or null if none

    • getConstructor

      @Nullable public Constructor<?> getConstructor()
      Return the wrapped Constructor, if any.

      Note: Either Method or Constructor is available.

      Returns:
      the Constructor, or null if none

    • getDeclaringClass

      public Class<?> getDeclaringClass()
      Return the class that declares the underlying Method or Constructor.

    • getMember

      public Member getMember()
      Return the wrapped member.
      Returns:
      the Method or Constructor as Member

    • getAnnotatedElement

      public AnnotatedElement getAnnotatedElement()
      Return the wrapped annotated element.

      Note: This method exposes the annotations declared on the method/constructor itself (i.e. at the method/constructor level, not at the parameter level).

      Returns:
      the Method or Constructor as AnnotatedElement

    • getExecutable

      public Executable getExecutable()
      Return the wrapped executable.
      Returns:
      the Method or Constructor as Executable
      Since:
      5.0

    • getParameter

      public Parameter getParameter()
      Return the Parameter descriptor for method/constructor parameter.
      Since:
      5.0

    • getParameterIndex

      public int getParameterIndex()
      Return the index of the method/constructor parameter.
      Returns:
      the parameter index (-1 in case of the return type)

    • increaseNestingLevel

      @Deprecated public void increaseNestingLevel()
      Deprecated.
      since 5.2 in favor of nested(Integer)
      Increase this parameter's nesting level.
      See Also:

    • decreaseNestingLevel

      @Deprecated public void decreaseNestingLevel()
      Deprecated.
      since 5.2 in favor of retaining the original MethodParameter and using nested(Integer) if nesting is required
      Decrease this parameter's nesting level.
      See Also:

    • getNestingLevel

      public int getNestingLevel()
      Return the nesting level of the target type (typically 1; e.g. in case of a List of Lists, 1 would indicate the nested List, whereas 2 would indicate the element of the nested List).

    • withTypeIndex

      public MethodParameter withTypeIndex(int typeIndex)
      Return a variant of this MethodParameter with the type for the current level set to the specified value.
      Parameters:
      typeIndex - the new type index
      Since:
      5.2

    • setTypeIndexForCurrentLevel

      @Deprecated public void setTypeIndexForCurrentLevel(int typeIndex)
      Deprecated.
      since 5.2 in favor of withTypeIndex(int)
      Set the type index for the current nesting level.
      Parameters:
      typeIndex - the corresponding type index (or null for the default type index)
      See Also:

    • getTypeIndexForCurrentLevel

      @Nullable public Integer getTypeIndexForCurrentLevel()
      Return the type index for the current nesting level.
      Returns:
      the corresponding type index, or null if none specified (indicating the default type index)
      See Also:

    • getTypeIndexForLevel

      @Nullable public Integer getTypeIndexForLevel(int nestingLevel)
      Return the type index for the specified nesting level.
      Parameters:
      nestingLevel - the nesting level to check
      Returns:
      the corresponding type index, or null if none specified (indicating the default type index)

    • nested

      public MethodParameter nested()
      Return a variant of this MethodParameter which points to the same parameter but one nesting level deeper.
      Since:
      4.3

    • nested

      public MethodParameter nested(@Nullable Integer typeIndex)
      Return a variant of this MethodParameter which points to the same parameter but one nesting level deeper.
      Parameters:
      typeIndex - the type index for the new nesting level
      Since:
      5.2

    • isOptional

      public boolean isOptional()
      Return whether this method indicates a parameter which is not required: either in the form of Java 8's Optional, any variant of a parameter-level Nullable annotation (such as from JSR-305 or the FindBugs set of annotations), or a language-level nullable type declaration or Continuation parameter in Kotlin.
      Since:
      4.3

    • nestedIfOptional

      public MethodParameter nestedIfOptional()
      Return a variant of this MethodParameter which points to the same parameter but one nesting level deeper in case of a Optional declaration.
      Since:
      4.3
      See Also:

    • withContainingClass

      public MethodParameter withContainingClass(@Nullable Class<?> containingClass)
      Return a variant of this MethodParameter which refers to the given containing class.
      Parameters:
      containingClass - a specific containing class (potentially a subclass of the declaring class, e.g. substituting a type variable)
      Since:
      5.2
      See Also:

    • getContainingClass

      public Class<?> getContainingClass()
      Return the containing class for this method parameter.
      Returns:
      a specific containing class (potentially a subclass of the declaring class), or otherwise simply the declaring class itself
      See Also:

    • getParameterType

      public Class<?> getParameterType()
      Return the type of the method/constructor parameter.
      Returns:
      the parameter type (never null)

    • getGenericParameterType

      public Type getGenericParameterType()
      Return the generic type of the method/constructor parameter.
      Returns:
      the parameter type (never null)
      Since:
      3.0

    • getNestedParameterType

      public Class<?> getNestedParameterType()
      Return the nested type of the method/constructor parameter.
      Returns:
      the parameter type (never null)
      Since:
      3.1
      See Also:

    • getNestedGenericParameterType

      public Type getNestedGenericParameterType()
      Return the nested generic type of the method/constructor parameter.
      Returns:
      the parameter type (never null)
      Since:
      4.2
      See Also:

    • getMethodAnnotations

      public Annotation[] getMethodAnnotations()
      Return the annotations associated with the target method/constructor itself.

    • getMethodAnnotation

      @Nullable public <A extends Annotation> A getMethodAnnotation(Class<A> annotationType)
      Return the method/constructor annotation of the given type, if available.
      Parameters:
      annotationType - the annotation type to look for
      Returns:
      the annotation object, or null if not found

    • hasMethodAnnotation

      public <A extends Annotation> boolean hasMethodAnnotation(Class<A> annotationType)
      Return whether the method/constructor is annotated with the given type.
      Parameters:
      annotationType - the annotation type to look for
      Since:
      4.3
      See Also:

    • getParameterAnnotations

      public Annotation[] getParameterAnnotations()
      Return the annotations associated with the specific method/constructor parameter.

    • hasParameterAnnotations

      public boolean hasParameterAnnotations()
      Return true if the parameter has at least one annotation, false if it has none.
      See Also:

    • getParameterAnnotation

      @Nullable public <A extends Annotation> A getParameterAnnotation(Class<A> annotationType)
      Return the parameter annotation of the given type, if available.
      Parameters:
      annotationType - the annotation type to look for
      Returns:
      the annotation object, or null if not found

    • hasParameterAnnotation

      public <A extends Annotation> boolean hasParameterAnnotation(Class<A> annotationType)
      Return whether the parameter is declared with the given annotation type.
      Parameters:
      annotationType - the annotation type to look for
      See Also:

    • initParameterNameDiscovery

      public void initParameterNameDiscovery(@Nullable ParameterNameDiscoverer parameterNameDiscoverer)
      Initialize parameter name discovery for this method parameter.

      This method does not actually try to retrieve the parameter name at this point; it just allows discovery to happen when the application calls getParameterName() (if ever).

    • getParameterName

      @Nullable public String getParameterName()
      Return the name of the method/constructor parameter.
      Returns:
      the parameter name (may be null if no parameter name metadata is contained in the class file or no ParameterNameDiscoverer has been set to begin with)

    • adaptAnnotation

      protected <A extends Annotation> A adaptAnnotation(A annotation)
      A template method to post-process a given annotation instance before returning it to the caller.

      The default implementation simply returns the given annotation as-is.

      Parameters:
      annotation - the annotation about to be returned
      Returns:
      the post-processed annotation (or simply the original one)
      Since:
      4.2

    • adaptAnnotationArray

      protected Annotation[] adaptAnnotationArray(Annotation[] annotations)
      A template method to post-process a given annotation array before returning it to the caller.

      The default implementation simply returns the given annotation array as-is.

      Parameters:
      annotations - the annotation array about to be returned
      Returns:
      the post-processed annotation array (or simply the original one)
      Since:
      4.2

    • equals

      public boolean equals(@Nullable Object other)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • clone

      public MethodParameter clone()
      Overrides:
      clone in class Object

    • forMethodOrConstructor

      @Deprecated public static MethodParameter forMethodOrConstructor(Object methodOrConstructor, int parameterIndex)
      Deprecated.
      as of 5.0, in favor of forExecutable(java.lang.reflect.Executable, int)
      Create a new MethodParameter for the given method or constructor.

      This is a convenience factory method for scenarios where a Method or Constructor reference is treated in a generic fashion.

      Parameters:
      methodOrConstructor - the Method or Constructor to specify a parameter for
      parameterIndex - the index of the parameter
      Returns:
      the corresponding MethodParameter instance

    • forExecutable

      public static MethodParameter forExecutable(Executable executable, int parameterIndex)
      Create a new MethodParameter for the given method or constructor.

      This is a convenience factory method for scenarios where a Method or Constructor reference is treated in a generic fashion.

      Parameters:
      executable - the Method or Constructor to specify a parameter for
      parameterIndex - the index of the parameter
      Returns:
      the corresponding MethodParameter instance
      Since:
      5.0

    • forParameter

      public static MethodParameter forParameter(Parameter parameter)
      Create a new MethodParameter for the given parameter descriptor.

      This is a convenience factory method for scenarios where a Java 8 Parameter descriptor is already available.

      Parameters:
      parameter - the parameter descriptor
      Returns:
      the corresponding MethodParameter instance
      Since:
      5.0

    • findParameterIndex

      protected static int findParameterIndex(Parameter parameter)

    • forFieldAwareConstructor

      public static MethodParameter forFieldAwareConstructor(Constructor<?> ctor, int parameterIndex, String fieldName)
      Create a new MethodParameter for the given field-aware constructor, e.g. on a data class or record type.

      A field-aware method parameter will detect field annotations as well, as long as the field name matches the parameter name.

      Parameters:
      ctor - the Constructor to specify a parameter for
      parameterIndex - the index of the parameter
      fieldName - the name of the underlying field, matching the constructor's parameter name
      Returns:
      the corresponding MethodParameter instance
      Since:
      6.1