org.springframework.core

## 类 ResolvableType

- java.lang.Object
- - org.springframework.core.ResolvableType

- 所有已实现的接口:
    Serializable

      public class ResolvableType
      extends Object
      implements Serializable

  Encapsulates a Java `Type`, providing access to `supertypes`, `interfaces`, and `generic parameters` along with the ability to ultimately `resolve` to a `Class`.

  `ResolvableTypes` may be obtained from `fields`, `method parameters`, `method returns` or `classes`. Most methods on this class will themselves return `ResolvableType`s, allowing easy navigation. For example:

       private HashMap<Integer, List<String>> myMap;

       public void example() {
           ResolvableType t = ResolvableType.forField(getClass().getDeclaredField("myMap"));
           t.getSuperType(); // AbstractMap<Integer, List<String>>
           t.asMap(); // Map<Integer, List<String>>
           t.getGeneric(0).resolve(); // Integer
           t.getGeneric(1).resolve(); // List
           t.getGeneric(1); // List<String>
           t.resolveGeneric(1, 0); // String
       }

  从以下版本开始:
    4.0
  作者:
    Phillip Webb, Juergen Hoeller, Stephane Nicoll
  另请参阅:
    `forField(Field)`, `forMethodParameter(Method, int)`, `forMethodReturnType(Method)`, `forConstructorParameter(Constructor, int)`, `forClass(Class)`, `forType(Type)`, `forInstance(Object)`, `ResolvableTypeProvider`, 序列化表格

- - ### 字段概要

    字段
    限定符和类型 | 字段和说明
    --- | ---
    `static ResolvableType` | `NONE` `ResolvableType` returned when no value is available.

  - ### 方法概要

    所有方法 静态方法 实例方法 具体方法
    限定符和类型 | 方法和说明
    --- | ---
    `ResolvableType` | `as(Class<?> type)` Return this type as a `ResolvableType` of the specified class.
    `ResolvableType` | `asCollection()` Convenience method to return this type as a resolvable `Collection` type.
    `ResolvableType` | `asMap()` Convenience method to return this type as a resolvable `Map` type.
    `static void` | `clearCache()` Clear the internal `ResolvableType`/`SerializableTypeWrapper` cache.
    `boolean` | `equals(Object other)`
    `static ResolvableType` | `forArrayComponent(ResolvableType componentType)` Return a `ResolvableType` as a array of the specified `componentType`.
    `static ResolvableType` | `forClass(Class<?> clazz)` Return a `ResolvableType` for the specified `Class`, using the full generic type information for assignability checks.
    `static ResolvableType` | `forClass(Class<?> baseType, Class<?> implementationClass)` Return a `ResolvableType` for the specified base type (interface or base class) with a given implementation class.
    `static ResolvableType` | `forClassWithGenerics(Class<?> clazz, Class<?>... generics)` Return a `ResolvableType` for the specified `Class` with pre-declared generics.
    `static ResolvableType` | `forClassWithGenerics(Class<?> clazz, ResolvableType... generics)` Return a `ResolvableType` for the specified `Class` with pre-declared generics.
    `static ResolvableType` | `forConstructorParameter(Constructor<?> constructor, int parameterIndex)` Return a `ResolvableType` for the specified `Constructor` parameter.
    `static ResolvableType` | `forConstructorParameter(Constructor<?> constructor, int parameterIndex, Class<?> implementationClass)` Return a `ResolvableType` for the specified `Constructor` parameter with a given implementation.
    `static ResolvableType` | `forField(Field field)` Return a `ResolvableType` for the specified `Field`.
    `static ResolvableType` | `forField(Field field, Class<?> implementationClass)` Return a `ResolvableType` for the specified `Field` with a given implementation.
    `static ResolvableType` | `forField(Field field, int nestingLevel)` Return a `ResolvableType` for the specified `Field` with the given nesting level.
    `static ResolvableType` | `forField(Field field, int nestingLevel, Class<?> implementationClass)` Return a `ResolvableType` for the specified `Field` with a given implementation and the given nesting level.
    `static ResolvableType` | `forField(Field field, ResolvableType implementationType)` Return a `ResolvableType` for the specified `Field` with a given implementation.
    `static ResolvableType` | `forInstance(Object instance)` Return a `ResolvableType` for the specified instance.
    `static ResolvableType` | `forMethodParameter(Method method, int parameterIndex)` Return a `ResolvableType` for the specified `Method` parameter.
    `static ResolvableType` | `forMethodParameter(Method method, int parameterIndex, Class<?> implementationClass)` Return a `ResolvableType` for the specified `Method` parameter with a given implementation.
    `static ResolvableType` | `forMethodParameter(MethodParameter methodParameter)` Return a `ResolvableType` for the specified `MethodParameter`.
    `static ResolvableType` | `forMethodParameter(MethodParameter methodParameter, ResolvableType implementationType)` Return a `ResolvableType` for the specified `MethodParameter` with a given implementation type.
    `static ResolvableType` | `forMethodParameter(MethodParameter methodParameter, Type targetType)` Return a `ResolvableType` for the specified `MethodParameter`, overriding the target type to resolve with a specific given type.
    `static ResolvableType` | `forMethodReturnType(Method method)` Return a `ResolvableType` for the specified `Method` return type.
    `static ResolvableType` | `forMethodReturnType(Method method, Class<?> implementationClass)` Return a `ResolvableType` for the specified `Method` return type.
    `static ResolvableType` | `forRawClass(Class<?> clazz)` Return a `ResolvableType` for the specified `Class`, doing assignability checks against the raw class only (analogous to `Class.isAssignableFrom(java.lang.Class<?>)`, which this serves as a wrapper for.
    `static ResolvableType` | `forType(ParameterizedTypeReference<?> typeReference)` Return a `ResolvableType` for the specified `ParameterizedTypeReference`.
    `static ResolvableType` | `forType(Type type)` Return a `ResolvableType` for the specified `Type`.
    `static ResolvableType` | `forType(Type type, ResolvableType owner)` Return a `ResolvableType` for the specified `Type` backed by the given owner type.
    `ResolvableType` | `getComponentType()` Return the ResolvableType representing the component type of the array or `NONE` if this type does not represent an array.
    `ResolvableType` | `getGeneric(int... indexes)` Return a `ResolvableType` representing the generic parameter for the given indexes.
    `ResolvableType[]` | `getGenerics()` Return an array of `ResolvableType`s representing the generic parameters of this type.
    `ResolvableType[]` | `getInterfaces()` Return a `ResolvableType` array representing the direct interfaces implemented by this type.
    `ResolvableType` | `getNested(int nestingLevel)` Return a `ResolvableType` for the specified nesting level.
    `ResolvableType` | `getNested(int nestingLevel, Map<Integer,Integer> typeIndexesPerLevel)` Return a `ResolvableType` for the specified nesting level.
    `Class<?>` | `getRawClass()` Return the underlying Java `Class` being managed, if available; otherwise `null`.
    `Object` | `getSource()` Return the underlying source of the resolvable type.
    `ResolvableType` | `getSuperType()` Return a `ResolvableType` representing the direct supertype of this type.
    `Type` | `getType()` Return the underling Java `Type` being managed.
    `boolean` | `hasGenerics()` Return `true` if this type contains generic parameters.
    `int` | `hashCode()`
    `boolean` | `hasUnresolvableGenerics()` Determine whether the underlying type has any unresolvable generics: either through an unresolvable type variable on the type itself or through implementing a generic interface in a raw fashion, i.e. without substituting that interface's type variables.
    `boolean` | `isArray()` Return `true` if this type resolves to a Class that represents an array.
    `boolean` | `isAssignableFrom(Class<?> other)` Determine whether this `ResolvableType` is assignable from the specified other type.
    `boolean` | `isAssignableFrom(ResolvableType other)` Determine whether this `ResolvableType` is assignable from the specified other type.
    `boolean` | `isInstance(Object obj)` Determine whether the given object is an instance of this `ResolvableType`.
    `Class<?>` | `resolve()` Resolve this type to a `Class`, returning `null` if the type cannot be resolved.
    `Class<?>` | `resolve(Class<?> fallback)` Resolve this type to a `Class`, returning the specified `fallback` if the type cannot be resolved.
    `Class<?>` | `resolveGeneric(int... indexes)` Convenience method that will `get` and `resolve` a specific generic parameters.
    `Class<?>[]` | `resolveGenerics()` Convenience method that will `get` and `resolve` generic parameters.
    `Class<?>[]` | `resolveGenerics(Class<?> fallback)` Convenience method that will `get` and `resolve` generic parameters, using the specified `fallback` if any type cannot be resolved.
    `String` | `toString()` Return a String representation of this type in its fully resolved form (including any generic parameters).

    - ### 从类继承的方法 java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### 字段详细资料

    - #### NONE

          public static final ResolvableType NONE

      `ResolvableType` returned when no value is available. `NONE` is used in preference to `null` so that multiple method calls can be safely chained.

  - ### 方法详细资料

    - #### getType

          public Type getType()

      Return the underling Java `Type` being managed.

    - #### getRawClass

          @Nullable
          public Class<?> getRawClass()

      Return the underlying Java `Class` being managed, if available; otherwise `null`.

    - #### getSource

          public Object getSource()

      Return the underlying source of the resolvable type. Will return a `Field`, `MethodParameter` or `Type` depending on how the `ResolvableType` was constructed. With the exception of the `NONE` constant, this method will never return `null`. This method is primarily to provide access to additional type information or meta-data that alternative JVM languages may provide.

    - #### isInstance

          public boolean isInstance(@Nullable
                                    Object obj)

      Determine whether the given object is an instance of this `ResolvableType`.
      参数:
        `obj` - the object to check
      从以下版本开始:
        4.2
      另请参阅:
        `isAssignableFrom(Class)`

    - #### isAssignableFrom

          public boolean isAssignableFrom(Class<?> other)

      Determine whether this `ResolvableType` is assignable from the specified other type.
      参数:
        `other` - the type to be checked against (as a `Class`)
      从以下版本开始:
        4.2
      另请参阅:
        `isAssignableFrom(ResolvableType)`

    - #### isAssignableFrom

          public boolean isAssignableFrom(ResolvableType other)

      Determine whether this `ResolvableType` is assignable from the specified other type.

      Attempts to follow the same rules as the Java compiler, considering whether both the `resolved` `Class` is `assignable from` the given type as well as whether all `generics` are assignable.

      参数:
        `other` - the type to be checked against (as a `ResolvableType`)
      返回:
        `true` if the specified other type can be assigned to this `ResolvableType`; `false` otherwise

    - #### isArray

          public boolean isArray()

      Return `true` if this type resolves to a Class that represents an array.
      另请参阅:
        `getComponentType()`

    - #### getComponentType

          public ResolvableType getComponentType()

      Return the ResolvableType representing the component type of the array or `NONE` if this type does not represent an array.
      另请参阅:
        `isArray()`

    - #### asCollection

          public ResolvableType asCollection()

      Convenience method to return this type as a resolvable `Collection` type. Returns `NONE` if this type does not implement or extend `Collection`.
      另请参阅:
        `as(Class)`, `asMap()`

    - #### asMap

          public ResolvableType asMap()

      Convenience method to return this type as a resolvable `Map` type. Returns `NONE` if this type does not implement or extend `Map`.
      另请参阅:
        `as(Class)`, `asCollection()`

    - #### as

          public ResolvableType as(Class<?> type)

      Return this type as a `ResolvableType` of the specified class. Searches `supertype` and `interface` hierarchies to find a match, returning `NONE` if this type does not implement or extend the specified class.
      参数:
        `type` - the required type (typically narrowed)
      返回:
        a `ResolvableType` representing this object as the specified type, or `NONE` if not resolvable as that type
      另请参阅:
        `asCollection()`, `asMap()`, `getSuperType()`, `getInterfaces()`

    - #### getSuperType

          public ResolvableType getSuperType()

      Return a `ResolvableType` representing the direct supertype of this type. If no supertype is available this method returns `NONE`.
      另请参阅:
        `getInterfaces()`

    - #### getInterfaces

          public ResolvableType[] getInterfaces()

      Return a `ResolvableType` array representing the direct interfaces implemented by this type. If this type does not implement any interfaces an empty array is returned.
      另请参阅:
        `getSuperType()`

    - #### hasGenerics

          public boolean hasGenerics()

      Return `true` if this type contains generic parameters.
      另请参阅:
        `getGeneric(int...)`, `getGenerics()`

    - #### hasUnresolvableGenerics

          public boolean hasUnresolvableGenerics()

      Determine whether the underlying type has any unresolvable generics: either through an unresolvable type variable on the type itself or through implementing a generic interface in a raw fashion, i.e. without substituting that interface's type variables. The result will be `true` only in those two scenarios.

    - #### getNested

          public ResolvableType getNested(int nestingLevel)

      Return a `ResolvableType` for the specified nesting level. See `getNested(int, Map)` for details.
      参数:
        `nestingLevel` - the nesting level
      返回:
        the `ResolvableType` type, or `#NONE`

    - #### getNested

          public ResolvableType getNested(int nestingLevel,
                                          @Nullable
                                          Map<Integer,Integer> typeIndexesPerLevel)

      Return a `ResolvableType` for the specified nesting level.

      The nesting level refers to the specific generic parameter that should be returned. A nesting level of 1 indicates this type; 2 indicates the first nested generic; 3 the second; and so on. For example, given `List<Set<Integer>>` level 1 refers to the `List`, level 2 the `Set`, and level 3 the `Integer`.

      The `typeIndexesPerLevel` map can be used to reference a specific generic for the given level. For example, an index of 0 would refer to a `Map` key; whereas, 1 would refer to the value. If the map does not contain a value for a specific level the last generic will be used (e.g. a `Map` value).

      Nesting levels may also apply to array types; for example given `String[]`, a nesting level of 2 refers to `String`.

      If a type does not `contain` generics the `supertype` hierarchy will be considered.

      参数:
        `nestingLevel` - the required nesting level, indexed from 1 for the current type, 2 for the first nested generic, 3 for the second and so on
        `typeIndexesPerLevel` - a map containing the generic index for a given nesting level (may be `null`)
      返回:
        a `ResolvableType` for the nested level, or `NONE`

    - #### getGeneric

          public ResolvableType getGeneric(@Nullable
                                           int... indexes)

      Return a `ResolvableType` representing the generic parameter for the given indexes. Indexes are zero based; for example given the type `Map<Integer, List<String>>`, `getGeneric(0)` will access the `Integer`. Nested generics can be accessed by specifying multiple indexes; for example `getGeneric(1, 0)` will access the `String` from the nested `List`. For convenience, if no indexes are specified the first generic is returned.

      If no generic is available at the specified indexes `NONE` is returned.

      参数:
        `indexes` - the indexes that refer to the generic parameter (may be omitted to return the first generic)
      返回:
        a `ResolvableType` for the specified generic, or `NONE`
      另请参阅:
        `hasGenerics()`, `getGenerics()`, `resolveGeneric(int...)`, `resolveGenerics()`

    - #### getGenerics

          public ResolvableType[] getGenerics()

      Return an array of `ResolvableType`s representing the generic parameters of this type. If no generics are available an empty array is returned. If you need to access a specific generic consider using the `getGeneric(int...)` method as it allows access to nested generics and protects against `IndexOutOfBoundsExceptions`.
      返回:
        an array of `ResolvableType`s representing the generic parameters (never `null`)
      另请参阅:
        `hasGenerics()`, `getGeneric(int...)`, `resolveGeneric(int...)`, `resolveGenerics()`

    - #### resolveGenerics

          public Class<?>[] resolveGenerics()

      Convenience method that will `get` and `resolve` generic parameters.
      返回:
        an array of resolved generic parameters (the resulting array will never be `null`, but it may contain `null` elements})
      另请参阅:
        `getGenerics()`, `resolve()`

    - #### resolveGenerics

          public Class<?>[] resolveGenerics(Class<?> fallback)

      Convenience method that will `get` and `resolve` generic parameters, using the specified `fallback` if any type cannot be resolved.
      参数:
        `fallback` - the fallback class to use if resolution fails
      返回:
        an array of resolved generic parameters
      另请参阅:
        `getGenerics()`, `resolve()`

    - #### resolveGeneric

          @Nullable
          public Class<?> resolveGeneric(int... indexes)

      Convenience method that will `get` and `resolve` a specific generic parameters.
      参数:
        `indexes` - the indexes that refer to the generic parameter (may be omitted to return the first generic)
      返回:
        a resolved `Class` or `null`
      另请参阅:
        `getGeneric(int...)`, `resolve()`

    - #### resolve

          @Nullable
          public Class<?> resolve()

      Resolve this type to a `Class`, returning `null` if the type cannot be resolved. This method will consider bounds of `TypeVariable`s and `WildcardType`s if direct resolution fails; however, bounds of `Object.class` will be ignored.
      返回:
        the resolved `Class`, or `null` if not resolvable
      另请参阅:
        `resolve(Class)`, `resolveGeneric(int...)`, `resolveGenerics()`

    - #### resolve

          public Class<?> resolve(Class<?> fallback)

      Resolve this type to a `Class`, returning the specified `fallback` if the type cannot be resolved. This method will consider bounds of `TypeVariable`s and `WildcardType`s if direct resolution fails; however, bounds of `Object.class` will be ignored.
      参数:
        `fallback` - the fallback class to use if resolution fails
      返回:
        the resolved `Class` or the `fallback`
      另请参阅:
        `resolve()`, `resolveGeneric(int...)`, `resolveGenerics()`

    - #### equals

          public boolean equals(Object other)

      覆盖:
        `equals` 在类中 `Object`

    - #### hashCode

          public int hashCode()

      覆盖:
        `hashCode` 在类中 `Object`

    - #### toString

          public String toString()

      Return a String representation of this type in its fully resolved form (including any generic parameters).
      覆盖:
        `toString` 在类中 `Object`

    - #### forClass

          public static ResolvableType forClass(@Nullable
                                                Class<?> clazz)

      Return a `ResolvableType` for the specified `Class`, using the full generic type information for assignability checks. For example: `ResolvableType.forClass(MyArrayList.class)`.
      参数:
        `clazz` - the class to introspect (`null` is semantically equivalent to `Object.class` for typical use cases here}
      返回:
        a `ResolvableType` for the specified class
      另请参阅:
        `forClass(Class, Class)`, `forClassWithGenerics(Class, Class...)`

    - #### forRawClass

          public static ResolvableType forRawClass(@Nullable
                                                   Class<?> clazz)

      Return a `ResolvableType` for the specified `Class`, doing assignability checks against the raw class only (analogous to `Class.isAssignableFrom(java.lang.Class<?>)`, which this serves as a wrapper for. For example: `ResolvableType.forRawClass(List.class)`.
      参数:
        `clazz` - the class to introspect (`null` is semantically equivalent to `Object.class` for typical use cases here}
      返回:
        a `ResolvableType` for the specified class
      从以下版本开始:
        4.2
      另请参阅:
        `forClass(Class)`, `getRawClass()`

    - #### forClass

          public static ResolvableType forClass(Class<?> baseType,
                                                Class<?> implementationClass)

      Return a `ResolvableType` for the specified base type (interface or base class) with a given implementation class. For example: `ResolvableType.forClass(List.class, MyArrayList.class)`.
      参数:
        `baseType` - the base type (must not be `null`)
        `implementationClass` - the implementation class
      返回:
        a `ResolvableType` for the specified base type backed by the given implementation class
      另请参阅:
        `forClass(Class)`, `forClassWithGenerics(Class, Class...)`

    - #### forClassWithGenerics

          public static ResolvableType forClassWithGenerics(Class<?> clazz,
                                                            Class<?>... generics)

      Return a `ResolvableType` for the specified `Class` with pre-declared generics.
      参数:
        `clazz` - the class (or interface) to introspect
        `generics` - the generics of the class
      返回:
        a `ResolvableType` for the specific class and generics
      另请参阅:
        `forClassWithGenerics(Class, ResolvableType...)`

    - #### forClassWithGenerics

          public static ResolvableType forClassWithGenerics(Class<?> clazz,
                                                            ResolvableType... generics)

      Return a `ResolvableType` for the specified `Class` with pre-declared generics.
      参数:
        `clazz` - the class (or interface) to introspect
        `generics` - the generics of the class
      返回:
        a `ResolvableType` for the specific class and generics
      另请参阅:
        `forClassWithGenerics(Class, Class...)`

    - #### forInstance

          public static ResolvableType forInstance(Object instance)

      Return a `ResolvableType` for the specified instance. The instance does not convey generic information but if it implements `ResolvableTypeProvider` a more precise `ResolvableType` can be used than the simple one based on the `Class instance`.
      参数:
        `instance` - the instance
      返回:
        a `ResolvableType` for the specified instance
      从以下版本开始:
        4.2
      另请参阅:
        `ResolvableTypeProvider`

    - #### forField

          public static ResolvableType forField(Field field)

      Return a `ResolvableType` for the specified `Field`.
      参数:
        `field` - the source field
      返回:
        a `ResolvableType` for the specified field
      另请参阅:
        `forField(Field, Class)`

    - #### forField

          public static ResolvableType forField(Field field,
                                                Class<?> implementationClass)

      Return a `ResolvableType` for the specified `Field` with a given implementation.

      Use this variant when the class that declares the field includes generic parameter variables that are satisfied by the implementation class.

      参数:
        `field` - the source field
        `implementationClass` - the implementation class
      返回:
        a `ResolvableType` for the specified field
      另请参阅:
        `forField(Field)`

    - #### forField

          public static ResolvableType forField(Field field,
                                                @Nullable
                                                ResolvableType implementationType)

      Return a `ResolvableType` for the specified `Field` with a given implementation.

      Use this variant when the class that declares the field includes generic parameter variables that are satisfied by the implementation type.

      参数:
        `field` - the source field
        `implementationType` - the implementation type
      返回:
        a `ResolvableType` for the specified field
      另请参阅:
        `forField(Field)`

    - #### forField

          public static ResolvableType forField(Field field,
                                                int nestingLevel)

      Return a `ResolvableType` for the specified `Field` with the given nesting level.
      参数:
        `field` - the source field
        `nestingLevel` - the nesting level (1 for the outer level; 2 for a nested generic type; etc)
      另请参阅:
        `forField(Field)`

    - #### forField

          public static ResolvableType forField(Field field,
                                                int nestingLevel,
                                                @Nullable
                                                Class<?> implementationClass)

      Return a `ResolvableType` for the specified `Field` with a given implementation and the given nesting level.

      Use this variant when the class that declares the field includes generic parameter variables that are satisfied by the implementation class.

      参数:
        `field` - the source field
        `nestingLevel` - the nesting level (1 for the outer level; 2 for a nested generic type; etc)
        `implementationClass` - the implementation class
      返回:
        a `ResolvableType` for the specified field
      另请参阅:
        `forField(Field)`

    - #### forConstructorParameter

          public static ResolvableType forConstructorParameter(Constructor<?> constructor,
                                                               int parameterIndex)

      Return a `ResolvableType` for the specified `Constructor` parameter.
      参数:
        `constructor` - the source constructor (must not be `null`)
        `parameterIndex` - the parameter index
      返回:
        a `ResolvableType` for the specified constructor parameter
      另请参阅:
        `forConstructorParameter(Constructor, int, Class)`

    - #### forConstructorParameter

          public static ResolvableType forConstructorParameter(Constructor<?> constructor,
                                                               int parameterIndex,
                                                               Class<?> implementationClass)

      Return a `ResolvableType` for the specified `Constructor` parameter with a given implementation. Use this variant when the class that declares the constructor includes generic parameter variables that are satisfied by the implementation class.
      参数:
        `constructor` - the source constructor (must not be `null`)
        `parameterIndex` - the parameter index
        `implementationClass` - the implementation class
      返回:
        a `ResolvableType` for the specified constructor parameter
      另请参阅:
        `forConstructorParameter(Constructor, int)`

    - #### forMethodReturnType

          public static ResolvableType forMethodReturnType(Method method)

      Return a `ResolvableType` for the specified `Method` return type.
      参数:
        `method` - the source for the method return type
      返回:
        a `ResolvableType` for the specified method return
      另请参阅:
        `forMethodReturnType(Method, Class)`

    - #### forMethodReturnType

          public static ResolvableType forMethodReturnType(Method method,
                                                           Class<?> implementationClass)

      Return a `ResolvableType` for the specified `Method` return type. Use this variant when the class that declares the method includes generic parameter variables that are satisfied by the implementation class.
      参数:
        `method` - the source for the method return type
        `implementationClass` - the implementation class
      返回:
        a `ResolvableType` for the specified method return
      另请参阅:
        `forMethodReturnType(Method)`

    - #### forMethodParameter

          public static ResolvableType forMethodParameter(Method method,
                                                          int parameterIndex)

      Return a `ResolvableType` for the specified `Method` parameter.
      参数:
        `method` - the source method (must not be `null`)
        `parameterIndex` - the parameter index
      返回:
        a `ResolvableType` for the specified method parameter
      另请参阅:
        `forMethodParameter(Method, int, Class)`, `forMethodParameter(MethodParameter)`

    - #### forMethodParameter

          public static ResolvableType forMethodParameter(Method method,
                                                          int parameterIndex,
                                                          Class<?> implementationClass)

      Return a `ResolvableType` for the specified `Method` parameter with a given implementation. Use this variant when the class that declares the method includes generic parameter variables that are satisfied by the implementation class.
      参数:
        `method` - the source method (must not be `null`)
        `parameterIndex` - the parameter index
        `implementationClass` - the implementation class
      返回:
        a `ResolvableType` for the specified method parameter
      另请参阅:
        `forMethodParameter(Method, int, Class)`, `forMethodParameter(MethodParameter)`

    - #### forMethodParameter

          public static ResolvableType forMethodParameter(MethodParameter methodParameter)

      Return a `ResolvableType` for the specified `MethodParameter`.
      参数:
        `methodParameter` - the source method parameter (must not be `null`)
      返回:
        a `ResolvableType` for the specified method parameter
      另请参阅:
        `forMethodParameter(Method, int)`

    - #### forMethodParameter

          public static ResolvableType forMethodParameter(MethodParameter methodParameter,
                                                          @Nullable
                                                          ResolvableType implementationType)

      Return a `ResolvableType` for the specified `MethodParameter` with a given implementation type. Use this variant when the class that declares the method includes generic parameter variables that are satisfied by the implementation type.
      参数:
        `methodParameter` - the source method parameter (must not be `null`)
        `implementationType` - the implementation type
      返回:
        a `ResolvableType` for the specified method parameter
      另请参阅:
        `forMethodParameter(MethodParameter)`

    - #### forMethodParameter

          public static ResolvableType forMethodParameter(MethodParameter methodParameter,
                                                          @Nullable
                                                          Type targetType)

      Return a `ResolvableType` for the specified `MethodParameter`, overriding the target type to resolve with a specific given type.
      参数:
        `methodParameter` - the source method parameter (must not be `null`)
        `targetType` - the type to resolve (a part of the method parameter's type)
      返回:
        a `ResolvableType` for the specified method parameter
      另请参阅:
        `forMethodParameter(Method, int)`

    - #### forArrayComponent

          public static ResolvableType forArrayComponent(ResolvableType componentType)

      Return a `ResolvableType` as a array of the specified `componentType`.
      参数:
        `componentType` - the component type
      返回:
        a `ResolvableType` as an array of the specified component type

    - #### forType

          public static ResolvableType forType(@Nullable
                                               Type type)

      Return a `ResolvableType` for the specified `Type`. Note: The resulting `ResolvableType` may not be `Serializable`.
      参数:
        `type` - the source type (potentially `null`)
      返回:
        a `ResolvableType` for the specified `Type`
      另请参阅:
        `forType(Type, ResolvableType)`

    - #### forType

          public static ResolvableType forType(@Nullable
                                               Type type,
                                               @Nullable
                                               ResolvableType owner)

      Return a `ResolvableType` for the specified `Type` backed by the given owner type. Note: The resulting `ResolvableType` may not be `Serializable`.
      参数:
        `type` - the source type or `null`
        `owner` - the owner type used to resolve variables
      返回:
        a `ResolvableType` for the specified `Type` and owner
      另请参阅:
        `forType(Type)`

    - #### forType

          public static ResolvableType forType(ParameterizedTypeReference<?> typeReference)

      Return a `ResolvableType` for the specified `ParameterizedTypeReference`. Note: The resulting `ResolvableType` may not be `Serializable`.
      参数:
        `typeReference` - the reference to obtain the source type from
      返回:
        a `ResolvableType` for the specified `ParameterizedTypeReference`
      从以下版本开始:
        4.3.12
      另请参阅:
        `forType(Type)`

    - #### clearCache

          public static void clearCache()

      Clear the internal `ResolvableType`/`SerializableTypeWrapper` cache.
      从以下版本开始:
        4.2