org.springframework.core

## 类 GenericTypeResolver

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

-     public abstract class GenericTypeResolver
      extends Object

  Helper class for resolving generic types against type variables.

  Mainly intended for usage within the framework, resolving method parameter types even when they are declared generically.

  从以下版本开始:
    2.5.2
  作者:
    Juergen Hoeller, Rob Harrop, Sam Brannen, Phillip Webb

- - ### 构造器概要

    构造器
    构造器和说明
    `GenericTypeResolver()`

  - ### 方法概要

    所有方法 静态方法 具体方法
    限定符和类型 | 方法和说明
    --- | ---
    `static Map<TypeVariable,Type>` | `getTypeVariableMap(Class<?> clazz)` Build a mapping of `TypeVariable names` to `concrete classes` for the specified `Class`.
    `static Class<?>` | `resolveParameterType(MethodParameter methodParameter, Class<?> implementationClass)` Determine the target type for the given generic parameter type.
    `static Class<?>` | `resolveReturnType(Method method, Class<?> clazz)` Determine the target type for the generic return type of the given method, where formal type variables are declared on the given class.
    `static Class<?>` | `resolveReturnTypeArgument(Method method, Class<?> genericIfc)` Resolve the single type argument of the given generic interface against the given target method which is assumed to return the given interface or an implementation of it.
    `static Type` | `resolveType(Type genericType, Class<?> contextClass)` Resolve the given generic type against the given context class, substituting type variables as far as possible.
    `static Class<?>` | `resolveType(Type genericType, Map<TypeVariable,Type> map)` Resolve the specified generic type against the given TypeVariable map.
    `static Class<?>` | `resolveTypeArgument(Class<?> clazz, Class<?> genericIfc)` Resolve the single type argument of the given generic interface against the given target class which is assumed to implement the generic interface and possibly declare a concrete type for its type variable.
    `static Class<?>[]` | `resolveTypeArguments(Class<?> clazz, Class<?> genericIfc)` Resolve the type arguments of the given generic interface against the given target class which is assumed to implement the generic interface and possibly declare concrete types for its type variables.

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

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### 构造器详细资料

    - #### GenericTypeResolver

          public GenericTypeResolver()

  - ### 方法详细资料

    - #### resolveParameterType

          public static Class<?> resolveParameterType(MethodParameter methodParameter,
                                                      Class<?> implementationClass)

      Determine the target type for the given generic parameter type.
      参数:
        `methodParameter` - the method parameter specification
        `implementationClass` - the class to resolve type variables against
      返回:
        the corresponding generic parameter or return type

    - #### resolveReturnType

          public static Class<?> resolveReturnType(Method method,
                                                   Class<?> clazz)

      Determine the target type for the generic return type of the given method, where formal type variables are declared on the given class.
      参数:
        `method` - the method to introspect
        `clazz` - the class to resolve type variables against
      返回:
        the corresponding generic parameter or return type

    - #### resolveReturnTypeArgument

          @Nullable
          public static Class<?> resolveReturnTypeArgument(Method method,
                                                                      Class<?> genericIfc)

      Resolve the single type argument of the given generic interface against the given target method which is assumed to return the given interface or an implementation of it.
      参数:
        `method` - the target method to check the return type of
        `genericIfc` - the generic interface or superclass to resolve the type argument from
      返回:
        the resolved parameter type of the method return type, or `null` if not resolvable or if the single argument is of type `WildcardType`.

    - #### resolveTypeArgument

          @Nullable
          public static Class<?> resolveTypeArgument(Class<?> clazz,
                                                                Class<?> genericIfc)

      Resolve the single type argument of the given generic interface against the given target class which is assumed to implement the generic interface and possibly declare a concrete type for its type variable.
      参数:
        `clazz` - the target class to check against
        `genericIfc` - the generic interface or superclass to resolve the type argument from
      返回:
        the resolved type of the argument, or `null` if not resolvable

    - #### resolveTypeArguments

          @Nullable
          public static Class<?>[] resolveTypeArguments(Class<?> clazz,
                                                                   Class<?> genericIfc)

      Resolve the type arguments of the given generic interface against the given target class which is assumed to implement the generic interface and possibly declare concrete types for its type variables.
      参数:
        `clazz` - the target class to check against
        `genericIfc` - the generic interface or superclass to resolve the type argument from
      返回:
        the resolved type of each argument, with the array size matching the number of actual type arguments, or `null` if not resolvable

    - #### resolveType

          public static Type resolveType(Type genericType,
                                         @Nullable
                                         Class<?> contextClass)

      Resolve the given generic type against the given context class, substituting type variables as far as possible.
      参数:
        `genericType` - the (potentially) generic type
        `contextClass` - a context class for the target type, for example a class in which the target type appears in a method signature (can be `null`)
      返回:
        the resolved type (possibly the given generic type as-is)
      从以下版本开始:
        5.0

    - #### resolveType

          public static Class<?> resolveType(Type genericType,
                                             Map<TypeVariable,Type> map)

      Resolve the specified generic type against the given TypeVariable map.

      Used by Spring Data.

      参数:
        `genericType` - the generic type to resolve
        `map` - the TypeVariable Map to resolved against
      返回:
        the type if it resolves to a Class, or `Object.class` otherwise

    - #### getTypeVariableMap

          public static Map<TypeVariable,Type> getTypeVariableMap(Class<?> clazz)

      Build a mapping of `TypeVariable names` to `concrete classes` for the specified `Class`. Searches all super types, enclosing types and interfaces.
      另请参阅:
        `resolveType(Type, Map)`