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

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`
`forFieldAwareConstructor(Constructor<?> ctor, int parameterIndex, String fieldName)`
Create a new MethodParameter for the given field-aware constructor, for example, on a data class or record type.
`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; for example, in case of a List of Lists, 1 would indicate the nested List, whereas 2 would indicate the element of the nested List).
`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 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; for example, 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; for example, 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).

To get the `AnnotatedElement` at the parameter level, use `getParameter()`.

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; for example, 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, for example, 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)

### forFieldAwareConstructor

public static MethodParameter forFieldAwareConstructor(Constructor<?> ctor, int parameterIndex, String fieldName)
Create a new MethodParameter for the given field-aware constructor, for example, 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