java.lang.Object
- cc.shacocloud.mirage.utils.ResolvableType

所有已实现的接口:

Serializable
```
public class ResolvableType
extends Object
implements Serializable
```
封装了一个Java Type
提供对 supertypes、interfaces和 generic parameters的访问，以及最终 resolve到一个Class。
参考 spring

另请参阅:

序列化表格

字段概要

字段
修饰符和类型字段说明

static ResolvableType NONE
ResolvableType在没有值的时候返回。

方法概要

所有方法静态方法实例方法具体方法
修饰符和类型	方法	说明
`ResolvableType`	`as(Class<?> type)`	返回这个类型作为指定类的`ResolvableType`。
`ResolvableType`	`asCollection()`	方便的方法是将此类型作为一个可解析的 `Collection`类型返回。
`ResolvableType`	`asMap()`	方便的方法是将此类型作为一个可解析的`Map`类型返回。
`static void`	`clearCache()`	清除内部`ResolvableType`/`SerializableTypeWrapper`缓存
`boolean`	`equals(@Nullable Object other)`
`static ResolvableType`	`forArrayComponent(@NotNull ResolvableType componentType)`	返回一个`ResolvableType`作为指定的`componentType`的数组
`static ResolvableType`	`forClass(@NotNull Class<?> baseType, Class<?> implementationClass)`	为指定的基类型（接口或基类）返回一个`ResolvableType`，并给定一个实现类。
`static @NotNull ResolvableType`	`forClass(@Nullable Class<?> clazz)`	为指定的`Class`返回一个`ResolvableType`，使用完整的通用类型信息进行分配性检查。
`static ResolvableType`	`forClassWithGenerics(@NotNull Class<?> clazz, ResolvableType @NotNull ... generics)`	为指定的`Class`返回一个`ResolvableType`，并预先声明了泛型。
`static ResolvableType`	`forClassWithGenerics(@NotNull Class<?> clazz, Class<?> @NotNull ... generics)`	为指定的`Class`返回一个`ResolvableType`，并预先声明了泛型
`static ResolvableType`	`forConstructorParameter(@NotNull Constructor<?> constructor, int parameterIndex)`	为指定的`Constructor`参数返回一个`ResolvableType`
`static ResolvableType`	`forConstructorParameter(@NotNull Constructor<?> constructor, int parameterIndex, Class<?> implementationClass)`	为指定的`Constructor`参数返回一个`ResolvableType`，并给定一个实现
`static ResolvableType`	`forField(@NotNull Field field)`	为指定的 `Field` 返回一个 `ResolvableType`
`static ResolvableType`	`forField(@NotNull Field field, int nestingLevel)`	为指定的`Field`返回一个`ResolvableType`，并给出嵌套级别
`static ResolvableType`	`forField(@NotNull Field field, int nestingLevel, @Nullable Class<?> implementationClass)`	为指定的`Field`返回一个`ResolvableType`，并给出嵌套级别
`static ResolvableType`	`forField(@NotNull Field field, @Nullable ResolvableType implementationType)`	为指定的`Field`返回一个`ResolvableType`，并给出实现。
`static ResolvableType`	`forField(@NotNull Field field, Class<?> implementationClass)`	为指定的`Field`返回一个`ResolvableType`，并给出实现。
`static ResolvableType`	`forMethodParameter(@NotNull MethodParameter methodParameter, @Nullable ResolvableType implementationType)`	为指定的`MethodParameter`返回一个具有*给定实现类型的`ResolvableType`。
`static ResolvableType`	`forMethodParameter(@NotNull MethodParameter methodParameter, @Nullable Type targetType)`	为指定的`MethodParameter`返回一个`ResolvableType`，重写目标类型以解决特定的给定类型。
`static ResolvableType`	`forMethodParameter(@NotNull Method method, int parameterIndex)`	为指定的`Method`参数返回一个`ResolvableType`
`static ResolvableType`	`forMethodParameter(@NotNull Method method, int parameterIndex, Class<?> implementationClass)`	为指定的`Method`参数返回一个`ResolvableType`
`static ResolvableType`	`forMethodParameter(MethodParameter methodParameter)`	为指定的`MethodParameter`返回一个`ResolvableType`
`static ResolvableType`	`forMethodReturnType(@NotNull Method method)`	为指定的`Method`返回类型返回一个`ResolvableType`。
`static ResolvableType`	`forMethodReturnType(@NotNull Method method, Class<?> implementationClass)`	为指定的`Method`返回类型，返回一个`ResolvableType`
`static @NotNull ResolvableType`	`forRawClass(@Nullable Class<?> clazz)`	为指定的`Class`返回一个`ResolvableType`，只对原始类进行可分配性检查（类似于`Class.isAssignableFrom(java.lang.Class<?>)`，它作为一个封装器）
`static ResolvableType`	`forType(@NotNull ParameterizedTypeReference<?> typeReference)`	为指定的`ParameterizedTypeReference`返回一个`ResolvableType`
`static ResolvableType`	`forType(@Nullable Type type)`	为指定的`Type`返回一个`ResolvableType`
`static ResolvableType`	`forType(@Nullable Type type, @Nullable ResolvableType owner)`	为指定的`Type`返回一个`ResolvableType`
`ResolvableType`	`getComponentType()`	返回代表数组组件类型的ResolvableType，或者 `NONE`如果该类型不代表数组。
`ResolvableType`	`getGeneric(int @Nullable ... indexes)`	返回一个`ResolvableType`，代表给定索引的通用参数。
`ResolvableType[]`	`getGenerics()`	返回一个`ResolvableTypes`的数组，代表这个类型的通用参数。
`ResolvableType[]`	`getInterfaces()`	返回一个`ResolvableType`数组，代表这个类型所实现的直接接口。
`ResolvableType`	`getNested(int nestingLevel)`	返回一个指定嵌套级别的`ResolvableType`
`ResolvableType`	`getNested(int nestingLevel, @Nullable Map<Integer,Integer> typeIndexesPerLevel)`	返回一个指定嵌套级别的`ResolvableType`
`@Nullable Class<?>`	`getRawClass()`	如果有的话，返回被管理的底层Java `Class`；否则`null`。
`Object`	`getSource()`	返回可解析类型的基本来源。
`ResolvableType`	`getSuperType()`	返回一个代表该类型的直接超类型的`ResolvableType`
`Type`	`getType()`	返回被管理的底层Java `Type`。
`boolean`	`hasGenerics()`	如果该类型包含通用参数，则返回`true`
`int`	`hashCode()`
`boolean`	`hasUnresolvableGenerics()`	确定底层类型是否有任何无法解决的泛型：通过类型本身的无法解决的类型变量或者通过以原始方式实现泛型接口，即不替换该接口的类型变量。
`boolean`	`isArray()`	如果该类型解析为一个代表数组的Class，则返回`true`
`boolean`	`isAssignableFrom(ResolvableType other)`	确定这个`ResolvableType` 是否可以从指定的其他类型中进行分配
`boolean`	`isAssignableFrom(Class<?> other)`	确定这个 `ResolvableType` 是否可以从指定的其他类型中进行分配。
`boolean`	`isInstance(@Nullable Object obj)`	确定给定的对象是否是这个 `ResolvableType` 的一个实例。
`@Nullable Class<?>`	`resolve()`	将此类型解析为 `Class`，如果该类型不能被解析，则返回`null`。
`Class<?>`	`resolve(Class<?> fallback)`	将此类型解析为`Class`，如果类型不能被解析，则返回指定的 `fallback`。
`@Nullable Class<?>`	`resolveGeneric(int... indexes)`	方便的方法，将`get`和 `resolve`一个特定的通用参数。
`Class<?>[]`	`resolveGenerics()`	方便的方法，将 `get` 和 `resolve`通用参数。
`Class<?>[]`	`resolveGenerics(Class<?> fallback)`	方便的方法，将 `get` 和 `resolve` 通用参数，如果有任何类型不能被解决，则使用指定的`fallback`。
`Class<?>`	`toClass()`	将此类型作为一个已解析的`Class`返回，如果没有特定的类可以被解析，则返回到 `Object`。
`String`	`toString()`	返回该类型的一个字符串表示，以其完全解析的形式（包括任何通用参数）

从类继承的方法 java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 字段详细资料
  - NONE
```
public static final ResolvableType NONE
```
    ResolvableType在没有值的时候返回。NONE优先于null，这样多个方法的调用就可以安全地被链起来。
- 方法详细资料
  - getType
```
public Type getType()
```
    返回被管理的底层Java Type。
  - getRawClass
```
@Nullable
public @Nullable Class<?> getRawClass()
```
    如果有的话，返回被管理的底层Java Class；否则null。
  - getSource
```
public Object getSource()
```
    返回可解析类型的基本来源。将返回一个Field、MethodParameter或Type，这取决于ResolvableType 是如何构造的。这个方法主要是为了提供对其他JVM语言可能提供的额外类型信息或元数据的访问。
  - toClass
```
public Class<?> toClass()
```
    将此类型作为一个已解析的Class返回，如果没有特定的类可以被解析，则返回到 Object。
    
    返回:
    
    解决了的 Class 或 Object 的回退问题
    
    另请参阅:
    
    getRawClass(), resolve(Class)
  - isInstance
```
public boolean isInstance(@Nullable
                          @Nullable Object obj)
```
    确定给定的对象是否是这个 ResolvableType 的一个实例。
    
    参数:
    
    obj - 要检查的对象
    
    另请参阅:
    
    isAssignableFrom(Class)
  - isAssignableFrom
```
public boolean isAssignableFrom(Class<?> other)
```
    确定这个 ResolvableType 是否可以从指定的其他类型中进行分配。
    
    参数:
    
    other - 要检查的类型（作为一个Class）
    
    另请参阅:
    
    isAssignableFrom(ResolvableType)
  - isAssignableFrom
```
public boolean isAssignableFrom(ResolvableType other)
```
    确定这个ResolvableType 是否可以从指定的其他类型中进行分配
    试图遵循与Java编译器相同的规则，考虑 resolved Class是否是 assignable from 给定类型以及所有generics是否是可分配的。
    
    参数:
    
    other - 要被检查的类型（作为一个ResolvableType）
    
    返回:
    
    true 如果指定的其他类型可以被分配给这个 ResolvableType; false否则
  - isArray
```
public boolean isArray()
```
    如果该类型解析为一个代表数组的Class，则返回true
    
    另请参阅:
    
    getComponentType()
  - getComponentType
```
public ResolvableType getComponentType()
```
    返回代表数组组件类型的ResolvableType，或者 NONE如果该类型不代表数组。
    
    另请参阅:
    
    isArray()
  - asCollection
```
public ResolvableType asCollection()
```
    方便的方法是将此类型作为一个可解析的 Collection类型返回。
    如果这个类型没有实现或扩展 Collection，则返回NONE。
    
    另请参阅:
    
    as(Class), asMap()
  - asMap
```
public ResolvableType asMap()
```
    方便的方法是将此类型作为一个可解析的Map类型返回。
    如果这个类型没有实现或扩展 Map，则返回NONE。
    
    另请参阅:
    
    as(Class), asCollection()
  - as
```
public ResolvableType as(Class<?> type)
```
    返回这个类型作为指定类的ResolvableType。搜索 supertype 和 interface 层次结构以找到匹配，如果此类型没有实现或扩展指定的类，则返回NONE
    
    参数:
    
    type - 所需类型(通常是缩小的)
    
    返回:
    
    a ResolvableType代表这个对象为指定的*类型，或者NONE如果不能被解析为该类型的话。
    
    另请参阅:
    
    asCollection(), asMap(), getSuperType(), getInterfaces()
  - getSuperType
```
public ResolvableType getSuperType()
```
    返回一个代表该类型的直接超类型的ResolvableType
    如果没有超类型可用，该方法将返回NONE。
    注意：产生的ResolvableType实例可能不是Serializable。
    
    另请参阅:
    
    getInterfaces()
  - getInterfaces
```
public ResolvableType[] getInterfaces()
```
    返回一个ResolvableType数组，代表这个类型所实现的直接接口。如果这个类型没有实现任何接口，则返回一个空数组。
    注意：产生的ResolvableType实例可能不是Serializable
    
    另请参阅:
    
    getSuperType()
  - hasGenerics
```
public boolean hasGenerics()
```
    如果该类型包含通用参数，则返回true
    
    另请参阅:
    
    getGeneric(int...), getGenerics()
  - hasUnresolvableGenerics
```
public boolean hasUnresolvableGenerics()
```
    确定底层类型是否有任何无法解决的泛型：通过类型本身的无法解决的类型变量或者通过以原始方式实现泛型接口，即不替换该接口的类型变量。只有在这两种情况下，结果才是true
  - getNested
```
public ResolvableType getNested(int nestingLevel)
```
    返回一个指定嵌套级别的ResolvableType
    详见getNested(int, Map)
    
    参数:
    
    nestingLevel - 嵌套层
    
    返回:
    
    的ResolvableType类型，或#NONE
  - getNested
```
public ResolvableType getNested(int nestingLevel,
                                @Nullable
                                @Nullable Map<Integer,Integer> typeIndexesPerLevel)
```
    返回一个指定嵌套级别的ResolvableType
    嵌套级别指的是应该被返回的特定泛型参数。嵌套级别为 1表示这个类型； 2表示第一个嵌套泛型； 3表示第二个；以此类推。
    例如，给定List<Set<Integer>级别1指的是List，级别2是Set，级别3是Integer
    
    参数:
    
    nestingLevel - 所需的嵌套级别，从1开始索引，代表当前的类型，2代表第一个嵌套的类，3代表第二个，以此类推。
    
    typeIndexesPerLevel - 一个包含给定嵌套层的通用索引的地图（可能是null）
    
    返回:
    
    嵌套层的ResolvableType，或者NONE
  - getGeneric
```
public ResolvableType getGeneric(int @Nullable ... indexes)
```
    返回一个ResolvableType，代表给定索引的通用参数。索引是基于零的；例如，给定类型 Map<Integer, List<String>>，getGeneric(0)将访问 Integer。嵌套的泛型可以通过指定多个索引来访问；
    例如，getGeneric(1, 0)将从嵌套的List中访问String。为了方便起见，如果没有指定索引，那么将返回第一个泛型。
    如果在指定的索引中没有可用的泛型，则返回NONE。
    
    参数:
    
    indexes - 指向通用参数的索引（可以省略，以返回第一个通用参数）。
    
    返回:
    
    一个ResolvableType用于指定的泛型，或者NONE
    
    另请参阅:
    
    hasGenerics(), getGenerics(), resolveGeneric(int...), resolveGenerics()
  - getGenerics
```
public ResolvableType[] getGenerics()
```
    返回一个ResolvableTypes的数组，代表这个类型的通用参数。如果没有可用的泛型，则返回一个空数组。如果你需要访问一个特定的泛型，可以考虑使用getGeneric(int...)方法，因为它允许访问嵌套的泛型并防止 IndexOutOfBoundsExceptions。
    
    返回:
    
    一个代表通用参数的 ResolvableTypes数组 (绝不是null)。
    
    另请参阅:
    
    hasGenerics(), getGeneric(int...), resolveGeneric(int...), resolveGenerics()
  - resolveGenerics
```
public Class<?>[] resolveGenerics()
```
    方便的方法，将 get 和 resolve通用参数。
    
    返回:
    
    一个已解决的通用参数数组（产生的数组永远不会是null，但它可能包含null元素}。
    
    另请参阅:
    
    getGenerics(), resolve()
  - resolveGenerics
```
public Class<?>[] resolveGenerics(Class<?> fallback)
```
    方便的方法，将 get 和 resolve 通用参数，如果有任何类型不能被解决，则使用指定的fallback。
    
    参数:
    
    fallback - 如果解析失败，将使用的后备类
    
    返回:
    
    一个已解决的通用参数数组
    
    另请参阅:
    
    getGenerics(), resolve()
  - resolveGeneric
```
@Nullable
public @Nullable Class<?> resolveGeneric(int... indexes)
```
    方便的方法，将get和 resolve一个特定的通用参数。
    
    参数:
    
    indexes - 指向通用参数的索引（可以省略，以返回第一个通用参数）。
    
    返回:
    
    一个已解决的 Class 或 null
    
    另请参阅:
    
    getGeneric(int...), resolve()
  - resolve
```
@Nullable
public @Nullable Class<?> resolve()
```
    将此类型解析为 Class，如果该类型不能被解析，则返回null。如果直接解析失败，该方法将考虑 TypeVariables和 WildcardTypes的边界；但是，Object.class的边界将被忽略。
    如果该方法返回一个非空的Class并且hasGenerics() 返回false，给定的类型将有效包裹一个普通的Class，如果需要，允许进行普通的Class处理。
    
    返回:
    
    已解决的Class，如果不能解决，则为null
    
    另请参阅:
    
    resolve(Class), resolveGeneric(int...), resolveGenerics()
  - resolve
```
public Class<?> resolve(Class<?> fallback)
```
    将此类型解析为Class，如果类型不能被解析，则返回指定的 fallback。如果直接解析失败，这个方法将考虑 TypeVariables 和 WildcardTypes 的边界；但是，Object.class的边界将被忽略。
    
    参数:
    
    fallback - 如果解析失败，将使用的后备类·
    
    返回:
    
    解决的 Class 或 fallback
    
    另请参阅:
    
    resolve(), resolveGeneric(int...), resolveGenerics()
  - equals
```
public boolean equals(@Nullable
                      @Nullable Object other)
```
    覆盖:
    
    equals 在类中 Object
  - hashCode
```
public int hashCode()
```
    覆盖:
    
    hashCode 在类中 Object
  - toString
```
public String toString()
```
    返回该类型的一个字符串表示，以其完全解析的形式（包括任何通用参数）
    
    覆盖:
    
    toString 在类中 Object
  - forClass
```
@Contract(value="_ -> new",
          pure=true)
@NotNull
public static @NotNull ResolvableType forClass(@Nullable
                                               @Nullable Class<?> clazz)
```
    为指定的Class返回一个ResolvableType，使用完整的通用类型信息进行分配性检查。
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forClass(Class, Class), forClassWithGenerics(Class, Class...)
  - forRawClass
```
@Contract(value="_ -> new",
          pure=true)
@NotNull
public static @NotNull ResolvableType forRawClass(@Nullable
                                                  @Nullable Class<?> clazz)
```
    为指定的Class返回一个ResolvableType，只对原始类进行可分配性检查（类似于Class.isAssignableFrom(java.lang.Class<?>)，它作为一个封装器）
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forClass(Class), getRawClass()
  - forClass
```
public static ResolvableType forClass(@NotNull
                                      @NotNull Class<?> baseType,
                                      Class<?> implementationClass)
```
    为指定的基类型（接口或基类）返回一个ResolvableType，并给定一个实现类。
    示例: ResolvableType.forClass(List.class, MyArrayList.class).
    
    参数:
    
    baseType - 基本类型（不能是null）。
    
    implementationClass - 实现类
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forClass(Class), forClassWithGenerics(Class, Class...)
  - forClassWithGenerics
```
public static ResolvableType forClassWithGenerics(@NotNull
                                                  @NotNull Class<?> clazz,
                                                  Class<?> @NotNull ... generics)
```
    为指定的Class返回一个ResolvableType，并预先声明了泛型
    
    参数:
    
    clazz - 类或接口
    
    generics - 类的泛型
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forClassWithGenerics(Class, ResolvableType...)
  - forClassWithGenerics
```
public static ResolvableType forClassWithGenerics(@NotNull
                                                  @NotNull Class<?> clazz,
                                                  ResolvableType @NotNull ... generics)
```
    为指定的Class返回一个ResolvableType，并预先声明了泛型。
    
    参数:
    
    clazz - 类或接口
    
    generics - 类的泛型
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forClassWithGenerics(Class, Class...)
  - forField
```
public static ResolvableType forField(@NotNull
                                      @NotNull Field field)
```
    为指定的 Field 返回一个 ResolvableType
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forField(Field, Class)
  - forField
```
public static ResolvableType forField(@NotNull
                                      @NotNull Field field,
                                      Class<?> implementationClass)
```
    为指定的Field返回一个ResolvableType，并给出实现。
    当声明字段的类包括由实现类满足的通用参数变量时，使用这个变体。
    
    参数:
    
    field - 字段
    
    implementationClass - 执行类
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forField(Field)
  - forField
```
public static ResolvableType forField(@NotNull
                                      @NotNull Field field,
                                      @Nullable
                                      @Nullable ResolvableType implementationType)
```
    为指定的Field返回一个ResolvableType，并给出实现。
    当声明字段的类包括由实现类满足的通用参数变量时，使用这个变体。
    
    参数:
    
    field - 字段
    
    implementationType - 执行类
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forField(Field)
  - forField
```
public static ResolvableType forField(@NotNull
                                      @NotNull Field field,
                                      int nestingLevel)
```
    为指定的Field返回一个ResolvableType，并给出嵌套级别
    
    参数:
    
    field - 字段
    
    nestingLevel - 嵌套级别（1代表外层；2代表嵌套的*通用类型；等等）
    
    另请参阅:
    
    forField(Field)
  - forField
```
public static ResolvableType forField(@NotNull
                                      @NotNull Field field,
                                      int nestingLevel,
                                      @Nullable
                                      @Nullable Class<?> implementationClass)
```
    为指定的Field返回一个ResolvableType，并给出嵌套级别
    当声明字段的类包括由实现类满足的通用参数变量时，使用这个变体
    
    参数:
    
    field - 字段
    
    nestingLevel - 嵌套级别（1代表外层；2代表嵌套的*通用类型；等等）
    
    implementationClass - 执行类
    
    另请参阅:
    
    forField(Field)
  - forConstructorParameter
```
public static ResolvableType forConstructorParameter(@NotNull
                                                     @NotNull Constructor<?> constructor,
                                                     int parameterIndex)
```
    为指定的Constructor参数返回一个ResolvableType
    
    参数:
    
    constructor - 构造函数
    
    parameterIndex - 参数索引
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forConstructorParameter(Constructor, int, Class)
  - forConstructorParameter
```
public static ResolvableType forConstructorParameter(@NotNull
                                                     @NotNull Constructor<?> constructor,
                                                     int parameterIndex,
                                                     Class<?> implementationClass)
```
    为指定的Constructor参数返回一个ResolvableType，并给定一个实现
    当声明构造函数的类包括通用参数变量时，请使用这个变体，这些变量由实现类满足。
    
    参数:
    
    constructor - 构造函数
    
    parameterIndex - 参数索引
    
    implementationClass - 实现类
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forConstructorParameter(Constructor, int)
  - forMethodReturnType
```
public static ResolvableType forMethodReturnType(@NotNull
                                                 @NotNull Method method)
```
    为指定的Method返回类型返回一个ResolvableType。
    
    参数:
    
    method - 方法返回类型的来源
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forMethodReturnType(Method, Class)
  - forMethodReturnType
```
public static ResolvableType forMethodReturnType(@NotNull
                                                 @NotNull Method method,
                                                 Class<?> implementationClass)
```
    为指定的Method返回类型，返回一个ResolvableType
    
    参数:
    
    method - 方法返回类型的来源
    
    implementationClass - 实现类
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forMethodReturnType(Method)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(@NotNull
                                                @NotNull Method method,
                                                int parameterIndex)
```
    为指定的Method参数返回一个ResolvableType
    
    参数:
    
    method - 方法返回类型的来源
    
    parameterIndex - 参数索引
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forMethodParameter(Method, int, Class), forMethodParameter(MethodParameter)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(@NotNull
                                                @NotNull Method method,
                                                int parameterIndex,
                                                Class<?> implementationClass)
```
    为指定的Method参数返回一个ResolvableType
    
    参数:
    
    method - 方法返回类型的来源
    
    parameterIndex - 参数索引
    
    implementationClass - 实现类
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forMethodParameter(Method, int, Class), forMethodParameter(MethodParameter)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(MethodParameter methodParameter)
```
    为指定的MethodParameter返回一个ResolvableType
    
    参数:
    
    methodParameter - 源方法参数（不能是null）
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forMethodParameter(Method, int)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(@NotNull
                                                @NotNull MethodParameter methodParameter,
                                                @Nullable
                                                @Nullable ResolvableType implementationType)
```
    为指定的MethodParameter返回一个具有*给定实现类型的ResolvableType。
    
    参数:
    
    methodParameter - 源方法参数（不能是null）
    
    implementationType - 实现类
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forMethodParameter(MethodParameter)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(@NotNull
                                                @NotNull MethodParameter methodParameter,
                                                @Nullable
                                                @Nullable Type targetType)
```
    为指定的MethodParameter返回一个ResolvableType，重写目标类型以解决特定的给定类型。
    
    参数:
    
    methodParameter - 源方法参数（不能是null）
    
    targetType - 要解决的类型（方法参数类型的一部分）
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forMethodParameter(Method, int)
  - forArrayComponent
```
public static ResolvableType forArrayComponent(@NotNull
                                               @NotNull ResolvableType componentType)
```
    返回一个ResolvableType作为指定的componentType的数组
    
    参数:
    
    componentType - 组件类型
    
    返回:
    
    ResolvableType
  - forType
```
public static ResolvableType forType(@Nullable
                                     @Nullable Type type)
```
    为指定的Type返回一个ResolvableType
    注意：产生的ResolvableType实例可能不是Serializable
    
    参数:
    
    type - 源类型（可能是null）
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forType(Type, ResolvableType)
  - forType
```
public static ResolvableType forType(@Nullable
                                     @Nullable Type type,
                                     @Nullable
                                     @Nullable ResolvableType owner)
```
    为指定的Type返回一个ResolvableType
    注意：产生的ResolvableType实例可能不是Serializable
    
    参数:
    
    type - 源类型（可能是null）
    
    owner - 用来解决变量的所有者类型
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forType(Type)
  - forType
```
public static ResolvableType forType(@NotNull
                                     @NotNull ParameterizedTypeReference<?> typeReference)
```
    为指定的ParameterizedTypeReference返回一个ResolvableType
    注意：产生的ResolvableType实例可能不是Serializable
    
    参数:
    
    typeReference - ParameterizedTypeReference
    
    返回:
    
    ResolvableType
    
    另请参阅:
    
    forType(Type)
  - clearCache
```
public static void clearCache()
```
    清除内部ResolvableType/SerializableTypeWrapper缓存

类 ResolvableType

字段概要

方法概要

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

字段详细资料

NONE

方法详细资料

getType

getRawClass

getSource

toClass

isInstance

isAssignableFrom

isAssignableFrom

isArray

getComponentType

asCollection

asMap

as

getSuperType

getInterfaces

hasGenerics

hasUnresolvableGenerics

getNested

getNested

getGeneric

getGenerics

resolveGenerics

resolveGenerics

resolveGeneric

resolve

resolve

equals

hashCode

toString

forClass

forRawClass

forClass

forClassWithGenerics

forClassWithGenerics

forField

forField

forField

forField

forField

forConstructorParameter

forConstructorParameter

forMethodReturnType

forMethodReturnType

forMethodParameter

forMethodParameter

forMethodParameter

forMethodParameter

forMethodParameter

forArrayComponent

forType

forType

forType

clearCache