public class MethodParameter extends Object
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.
SynthesizingMethodParameter| Constructor and 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  MethodParameterfor the given method, with nesting level 1. | 
| MethodParameter(Method method,
               int parameterIndex,
               int nestingLevel)Create a new  MethodParameterfor 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. | 
| Modifier and Type | Method and Description | 
|---|---|
| protected <A extends Annotation> | 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()Decrease this parameter's nesting level. | 
| 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> | 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  Parameterdescriptor for method/constructor parameter. | 
| <A extends Annotation> | 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> | hasMethodAnnotation(Class<A> annotationType)Return whether the method/constructor is annotated with the given type. | 
| <A extends Annotation> | hasParameterAnnotation(Class<A> annotationType)Return whether the parameter is declared with the given annotation type. | 
| boolean | hasParameterAnnotations()Return  trueif the parameter has at least one annotation,falseif it has none. | 
| void | increaseNestingLevel()Increase this parameter's nesting level. | 
| 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-levelNullableannotation (such as from JSR-305
 or the FindBugs set of annotations), or a language-level nullable type
 declaration in Kotlin. | 
| MethodParameter | nested()Return a variant of this  MethodParameterwhich points to the
 same parameter but one nesting level deeper. | 
| MethodParameter | nestedIfOptional()Return a variant of this  MethodParameterwhich points to
 the same parameter but one nesting level deeper in case of aOptionaldeclaration. | 
| void | setTypeIndexForCurrentLevel(int typeIndex)Set the type index for the current nesting level. | 
| String | toString() | 
public MethodParameter(Method method, int parameterIndex)
MethodParameter for the given method, with nesting level 1.method - the Method to specify a parameter forparameterIndex - the index of the parameter: -1 for the method
 return type; 0 for the first method parameter; 1 for the second method
 parameter, etc.public MethodParameter(Method method, int parameterIndex, int nestingLevel)
MethodParameter for the given method.method - the Method to specify a parameter forparameterIndex - 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)public MethodParameter(Constructor<?> constructor, int parameterIndex)
constructor - the Constructor to specify a parameter forparameterIndex - the index of the parameterpublic MethodParameter(Constructor<?> constructor, int parameterIndex, int nestingLevel)
constructor - the Constructor to specify a parameter forparameterIndex - the index of the parameternestingLevel - 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)public MethodParameter(MethodParameter original)
original - the original MethodParameter object to copy from@Nullable public Method getMethod()
Note: Either Method or Constructor is available.
null if none@Nullable public Constructor<?> getConstructor()
Note: Either Method or Constructor is available.
null if nonepublic Class<?> getDeclaringClass()
public Member getMember()
public AnnotatedElement getAnnotatedElement()
Note: This method exposes the annotations declared on the method/constructor itself (i.e. at the method/constructor level, not at the parameter level).
public Executable getExecutable()
public Parameter getParameter()
Parameter descriptor for method/constructor parameter.public int getParameterIndex()
public void increaseNestingLevel()
getNestingLevel()public void decreaseNestingLevel()
getNestingLevel()public int getNestingLevel()
public void setTypeIndexForCurrentLevel(int typeIndex)
typeIndex - the corresponding type index
 (or null for the default type index)getNestingLevel()@Nullable public Integer getTypeIndexForCurrentLevel()
null
 if none specified (indicating the default type index)getNestingLevel()@Nullable public Integer getTypeIndexForLevel(int nestingLevel)
nestingLevel - the nesting level to checknull
 if none specified (indicating the default type index)public MethodParameter nested()
MethodParameter which points to the
 same parameter but one nesting level deeper. This is effectively the
 same as increaseNestingLevel(), just with an independent
 MethodParameter object (e.g. in case of the original being cached).public boolean isOptional()
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 in Kotlin.public MethodParameter nestedIfOptional()
MethodParameter which points to
 the same parameter but one nesting level deeper in case of a
 Optional declaration.isOptional(), 
nested()public Class<?> getContainingClass()
getDeclaringClass()public Class<?> getParameterType()
null)public Type getGenericParameterType()
null)public Class<?> getNestedParameterType()
null)getNestingLevel()public Type getNestedGenericParameterType()
null)getNestingLevel()public Annotation[] getMethodAnnotations()
@Nullable public <A extends Annotation> A getMethodAnnotation(Class<A> annotationType)
annotationType - the annotation type to look fornull if not foundpublic <A extends Annotation> boolean hasMethodAnnotation(Class<A> annotationType)
annotationType - the annotation type to look forgetMethodAnnotation(Class)public Annotation[] getParameterAnnotations()
public boolean hasParameterAnnotations()
true if the parameter has at least one annotation,
 false if it has none.getParameterAnnotations()@Nullable public <A extends Annotation> A getParameterAnnotation(Class<A> annotationType)
annotationType - the annotation type to look fornull if not foundpublic <A extends Annotation> boolean hasParameterAnnotation(Class<A> annotationType)
annotationType - the annotation type to look forgetParameterAnnotation(Class)public void initParameterNameDiscovery(@Nullable ParameterNameDiscoverer parameterNameDiscoverer)
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).
@Nullable public String getParameterName()
null if no
 parameter name metadata is contained in the class file or no
 ParameterNameDiscoverer
 has been set to begin with)protected <A extends Annotation> A adaptAnnotation(A annotation)
The default implementation simply returns the given annotation as-is.
annotation - the annotation about to be returnedprotected Annotation[] adaptAnnotationArray(Annotation[] annotations)
The default implementation simply returns the given annotation array as-is.
annotations - the annotation array about to be returnedpublic MethodParameter clone()
@Deprecated public static MethodParameter forMethodOrConstructor(Object methodOrConstructor, int parameterIndex)
forExecutable(java.lang.reflect.Executable, int)This is a convenience factory method for scenarios where a Method or Constructor reference is treated in a generic fashion.
methodOrConstructor - the Method or Constructor to specify a parameter forparameterIndex - the index of the parameterpublic static MethodParameter forExecutable(Executable executable, int parameterIndex)
This is a convenience factory method for scenarios where a Method or Constructor reference is treated in a generic fashion.
executable - the Method or Constructor to specify a parameter forparameterIndex - the index of the parameterpublic static MethodParameter forParameter(Parameter parameter)
This is a convenience factory method for scenarios where a
 Java 8 Parameter descriptor is already available.
parameter - the parameter descriptorprotected static int findParameterIndex(Parameter parameter)