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:
SynthesizingMethodParameter

Constructor Summary

Constructors
Constructor	Description
`MethodParameter(Constructor<?> constructor, int parameterIndex)`	Create a new MethodParameter for the given constructor, with nesting level 1.
`MethodParameter(Constructor<?> constructor, int parameterIndex, int nestingLevel)`	Create a new MethodParameter for the given constructor.
`MethodParameter(Method method, int parameterIndex)`	Create a new `MethodParameter` for the given method, with nesting level 1.
`MethodParameter(Method method, int parameterIndex, int nestingLevel)`	Create a new `MethodParameter` for the given method.
`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.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`protected <A extends Annotation> A`	`adaptAnnotation(A annotation)`	A template method to post-process a given annotation instance before returning it to the caller.
`protected Annotation[]`	`adaptAnnotationArray(Annotation[] annotations)`	A template method to post-process a given annotation array before returning it to the caller.
`MethodParameter`	`clone()`
`void`	`decreaseNestingLevel()`	Deprecated. since 5.2 in favor of retaining the original MethodParameter and using `nested(Integer)` if nesting is required
`boolean`	`equals(Object other)`
`protected static int`	`findParameterIndex(Parameter parameter)`
`static MethodParameter`	`forExecutable(Executable executable, int parameterIndex)`	Create a new MethodParameter for the given method or constructor.
`static MethodParameter`	`forMethodOrConstructor(Object methodOrConstructor, int parameterIndex)`	Deprecated. as of 5.0, in favor of `forExecutable(java.lang.reflect.Executable, int)`
`static MethodParameter`	`forParameter(Parameter parameter)`	Create a new MethodParameter for the given parameter descriptor.
`AnnotatedElement`	`getAnnotatedElement()`	Return the wrapped annotated element.
`Constructor<?>`	`getConstructor()`	Return the wrapped Constructor, if any.
`Class<?>`	`getContainingClass()`	Return the containing class for this method parameter.
`Class<?>`	`getDeclaringClass()`	Return the class that declares the underlying Method or Constructor.
`Executable`	`getExecutable()`	Return the wrapped executable.
`Type`	`getGenericParameterType()`	Return the generic type of the method/constructor parameter.
`Member`	`getMember()`	Return the wrapped member.
`Method`	`getMethod()`	Return the wrapped Method, if any.
`<A extends Annotation> A`	`getMethodAnnotation(Class<A> annotationType)`	Return the method/constructor annotation of the given type, if available.
`Annotation[]`	`getMethodAnnotations()`	Return the annotations associated with the target method/constructor itself.
`Type`	`getNestedGenericParameterType()`	Return the nested generic type of the method/constructor parameter.
`Class<?>`	`getNestedParameterType()`	Return the nested type of the method/constructor parameter.
`int`	`getNestingLevel()`	Return the nesting level of the target type (typically 1; e.g.
`Parameter`	`getParameter()`	Return the `Parameter` descriptor for method/constructor parameter.
`<A extends Annotation> A`	`getParameterAnnotation(Class<A> annotationType)`	Return the parameter annotation of the given type, if available.
`Annotation[]`	`getParameterAnnotations()`	Return the annotations associated with the specific method/constructor parameter.
`int`	`getParameterIndex()`	Return the index of the method/constructor parameter.
`String`	`getParameterName()`	Return the name of the method/constructor parameter.
`Class<?>`	`getParameterType()`	Return the type of the method/constructor parameter.
`Integer`	`getTypeIndexForCurrentLevel()`	Return the type index for the current nesting level.
`Integer`	`getTypeIndexForLevel(int nestingLevel)`	Return the type index for the specified nesting level.
`int`	`hashCode()`
`<A extends Annotation> boolean`	`hasMethodAnnotation(Class<A> annotationType)`	Return whether the method/constructor is annotated with the given type.
`<A extends Annotation> boolean`	`hasParameterAnnotation(Class<A> annotationType)`	Return whether the parameter is declared with the given annotation type.
`boolean`	`hasParameterAnnotations()`	Return `true` if the parameter has at least one annotation, `false` if it has none.
`void`	`increaseNestingLevel()`	Deprecated. since 5.2 in favor of `nested(Integer)`
`void`	`initParameterNameDiscovery(ParameterNameDiscoverer parameterNameDiscoverer)`	Initialize parameter name discovery for this method parameter.
`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.
`MethodParameter`	`nested()`	Return a variant of this `MethodParameter` which points to the same parameter but one nesting level deeper.
`MethodParameter`	`nested(Integer typeIndex)`	Return a variant of this `MethodParameter` which points to the same parameter but one nesting level deeper.
`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.
`void`	`setTypeIndexForCurrentLevel(int typeIndex)`	Deprecated. since 5.2 in favor of `withTypeIndex(int)`
`String`	`toString()`
`MethodParameter`	`withContainingClass(Class<?> containingClass)`	Return a variant of this `MethodParameter` which refers to the given containing class.
`MethodParameter`	`withTypeIndex(int typeIndex)`	Return a variant of this `MethodParameter` with the type for the current level set to the specified value.

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - 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 Detail
  - 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:
    getNestingLevel()
  - 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()
  - 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:
    getNestingLevel()
  - 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:
    getNestingLevel()
  - 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:
    isOptional(), nested()
  - 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:
    getParameterType()
  - 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:
    getDeclaringClass()
  - 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:
    getNestingLevel()
  - 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:
    getNestingLevel()
  - 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:
    getMethodAnnotation(Class)
  - 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:
    getParameterAnnotations()
  - 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:
    getParameterAnnotation(Class)
  - 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)
```

Class MethodParameter

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

MethodParameter

MethodParameter

MethodParameter

MethodParameter

MethodParameter

Method Detail

getMethod

getConstructor

getDeclaringClass

getMember

getAnnotatedElement

getExecutable

getParameter

getParameterIndex

increaseNestingLevel

decreaseNestingLevel

getNestingLevel

withTypeIndex

setTypeIndexForCurrentLevel

getTypeIndexForCurrentLevel

getTypeIndexForLevel

nested

nested

isOptional

nestedIfOptional

withContainingClass

getContainingClass

getParameterType

getGenericParameterType

getNestedParameterType

getNestedGenericParameterType

getMethodAnnotations

getMethodAnnotation

hasMethodAnnotation

getParameterAnnotations

hasParameterAnnotations

getParameterAnnotation

hasParameterAnnotation

initParameterNameDiscovery

getParameterName

adaptAnnotation

adaptAnnotationArray

equals

hashCode

toString

clone

forMethodOrConstructor

forExecutable

forParameter

findParameterIndex