org.springframework.core

Class MethodParameter

  • java.lang.Object
    • org.springframework.core.MethodParameter
  • Direct Known Subclasses:
    SynthesizingMethodParameter


    public class MethodParameter
    extends java.lang.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
    See Also:
    SynthesizingMethodParameter
    • Constructor Summary

      Constructors 
      Constructor and Description
      MethodParameter(java.lang.reflect.Constructor<?> constructor, int parameterIndex)
      Create a new MethodParameter for the given constructor, with nesting level 1.
      MethodParameter(java.lang.reflect.Constructor<?> constructor, int parameterIndex, int nestingLevel)
      Create a new MethodParameter for the given constructor.
      MethodParameter(java.lang.reflect.Method method, int parameterIndex)
      Create a new MethodParameter for the given method, with nesting level 1.
      MethodParameter(java.lang.reflect.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 and Description
      protected <A extends java.lang.annotation.Annotation>
      A
      adaptAnnotation(A annotation)
      A template method to post-process a given annotation instance before returning it to the caller.
      protected java.lang.annotation.Annotation[] adaptAnnotationArray(java.lang.annotation.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(java.lang.Object other) 
      protected static int findParameterIndex(java.lang.reflect.Parameter parameter) 
      static MethodParameter forExecutable(java.lang.reflect.Executable executable, int parameterIndex)
      Create a new MethodParameter for the given method or constructor.
      static MethodParameter forMethodOrConstructor(java.lang.Object methodOrConstructor, int parameterIndex)
      Deprecated. 
      static MethodParameter forParameter(java.lang.reflect.Parameter parameter)
      Create a new MethodParameter for the given parameter descriptor.
      java.lang.reflect.AnnotatedElement getAnnotatedElement()
      Return the wrapped annotated element.
      java.lang.reflect.Constructor<?> getConstructor()
      Return the wrapped Constructor, if any.
      java.lang.Class<?> getContainingClass() 
      java.lang.Class<?> getDeclaringClass()
      Return the class that declares the underlying Method or Constructor.
      java.lang.reflect.Executable getExecutable()
      Return the wrapped executable.
      java.lang.reflect.Type getGenericParameterType()
      Return the generic type of the method/constructor parameter.
      java.lang.reflect.Member getMember()
      Return the wrapped member.
      java.lang.reflect.Method getMethod()
      Return the wrapped Method, if any.
      <A extends java.lang.annotation.Annotation>
      A
      getMethodAnnotation(java.lang.Class<A> annotationType)
      Return the method/constructor annotation of the given type, if available.
      java.lang.annotation.Annotation[] getMethodAnnotations()
      Return the annotations associated with the target method/constructor itself.
      java.lang.reflect.Type getNestedGenericParameterType()
      Return the nested generic type of the method/constructor parameter.
      java.lang.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.
      java.lang.reflect.Parameter getParameter()
      Return the Parameter descriptor for method/constructor parameter.
      <A extends java.lang.annotation.Annotation>
      A
      getParameterAnnotation(java.lang.Class<A> annotationType)
      Return the parameter annotation of the given type, if available.
      java.lang.annotation.Annotation[] getParameterAnnotations()
      Return the annotations associated with the specific method/constructor parameter.
      int getParameterIndex()
      Return the index of the method/constructor parameter.
      java.lang.String getParameterName()
      Return the name of the method/constructor parameter.
      java.lang.Class<?> getParameterType()
      Return the type of the method/constructor parameter.
      java.lang.Integer getTypeIndexForCurrentLevel()
      Return the type index for the current nesting level.
      java.lang.Integer getTypeIndexForLevel(int nestingLevel)
      Return the type index for the specified nesting level.
      int hashCode() 
      <A extends java.lang.annotation.Annotation>
      boolean
      hasMethodAnnotation(java.lang.Class<A> annotationType)
      Return whether the method/constructor is annotated with the given type.
      <A extends java.lang.annotation.Annotation>
      boolean
      hasParameterAnnotation(java.lang.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()
      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-level Nullable annotation (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 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)
      Set the type index for the current nesting level.
      java.lang.String toString() 
      • Methods inherited from class java.lang.Object

        finalize, getClass, notify, notifyAll, wait, wait, wait
    • Constructor Detail

      • MethodParameter

        public MethodParameter(java.lang.reflect.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(java.lang.reflect.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(java.lang.reflect.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(java.lang.reflect.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 java.lang.reflect.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 java.lang.reflect.Constructor<?> getConstructor()
        Return the wrapped Constructor, if any.

        Note: Either Method or Constructor is available.

        Returns:
        the Constructor, or null if none
      • getDeclaringClass

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

        public java.lang.reflect.Member getMember()
        Return the wrapped member.
        Returns:
        the Method or Constructor as Member
      • getAnnotatedElement

        public java.lang.reflect.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 java.lang.reflect.Executable getExecutable()
        Return the wrapped executable.
        Returns:
        the Method or Constructor as Executable
        Since:
        5.0
      • getParameter

        public java.lang.reflect.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

        public void increaseNestingLevel()
        Increase this parameter's nesting level.
        See Also:
        getNestingLevel()
      • decreaseNestingLevel

        public void decreaseNestingLevel()
        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).
      • setTypeIndexForCurrentLevel

        public void setTypeIndexForCurrentLevel(int typeIndex)
        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 java.lang.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 java.lang.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. This is effectively the same as increaseNestingLevel(), just with an independent MethodParameter object (e.g. in case of the original being cached).
        Since:
        4.3
      • 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 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()
      • getContainingClass

        public java.lang.Class<?> getContainingClass()
      • getParameterType

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

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

        public java.lang.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 java.lang.reflect.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 java.lang.annotation.Annotation[] getMethodAnnotations()
        Return the annotations associated with the target method/constructor itself.
      • getMethodAnnotation

        @Nullable
        public <A extends java.lang.annotation.Annotation> A getMethodAnnotation(java.lang.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 java.lang.annotation.Annotation> boolean hasMethodAnnotation(java.lang.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 java.lang.annotation.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 java.lang.annotation.Annotation> A getParameterAnnotation(java.lang.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 java.lang.annotation.Annotation> boolean hasParameterAnnotation(java.lang.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 java.lang.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 java.lang.annotation.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 java.lang.annotation.Annotation[] adaptAnnotationArray(java.lang.annotation.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(java.lang.Object other)
        Overrides:
        equals in class java.lang.Object
      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class java.lang.Object
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object
      • clone

        public MethodParameter clone()
        Overrides:
        clone in class java.lang.Object
      • forMethodOrConstructor

        @Deprecated
        public static MethodParameter forMethodOrConstructor(java.lang.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(java.lang.reflect.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(java.lang.reflect.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(java.lang.reflect.Parameter parameter)