cn.sexycode.util.core.cls

类 TypeResolver

java.lang.Object

cn.sexycode.util.core.cls.TypeResolver

public final class TypeResolver
extends Object

Enhanced type resolution utilities.

作者:

Jonathan Halterman

嵌套类概要

嵌套类

限定符和类型	类和说明
static class	TypeResolver.Unknown An unknown type.

方法概要

限定符和类型	方法和说明
static void	disableCache() Disables the internal caching of resolved TypeVariables.
static void	enableCache() Enables the internal caching of resolved TypeVariables.
static <T,S extends T> Type	reify(Class<T> type, Class<S> context) Traverses a generic type and replaces all type variables and wildcard types with concrete types (if possible), by using the type information from given context.
static Type	reify(Type type) Traverses a generic type and replaces all type variables and wildcard types with concrete types (if possible).
static Type	reify(Type type, Class<?> context) Traverses a generic type and replaces all type variables and wildcard types with concrete types (if possible), by using the type information from given context.
static Type	resolveBound(TypeVariable<?> typeVariable) Resolves the first bound for the typeVariable, returning Unknown.class if none can be resolved.
static Type	resolveGenericType(Class<?> type, Type subType) Returns the generic type using type variable information from the subType else null if the generic type cannot be resolved.
static <T,S extends T> Class<?>	resolveRawArgument(Class<T> type, Class<S> subType) Returns the raw class representing the argument for the type using type variable information from the subType.
static Class<?>	resolveRawArgument(Type genericType, Class<?> subType) Returns the raw class representing the argument for the genericType using type variable information from the subType.
static <T,S extends T> Class<?>[]	resolveRawArguments(Class<T> type, Class<S> subType) Returns an array of raw classes representing arguments for the type using type variable information from the subType.
static Class<?>[]	resolveRawArguments(Type genericType, Class<?> subType) Returns an array of raw classes representing arguments for the genericType using type variable information from the subType.
static Class<?>	resolveRawClass(Type genericType, Class<?> subType) Resolves the raw class for the genericType, using the type variable information from the subType else TypeResolver.Unknown if the raw class cannot be resolved.

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

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

方法详细资料

enableCache

public static void enableCache()

Enables the internal caching of resolved TypeVariables.

disableCache

public static void disableCache()

Disables the internal caching of resolved TypeVariables.

resolveRawArgument

public static <T,S extends T> Class<?> resolveRawArgument(Class<T> type,
                                                          Class<S> subType)

Returns the raw class representing the argument for the type using type variable information from the subType. If no arguments can be resolved then Unknown.class is returned.

参数:

type - to resolve argument for

subType - to extract type variable information from

返回:

argument for type else TypeResolver.Unknown.class if no type arguments are declared

抛出:

IllegalArgumentException - if more or less than one argument is resolved for the type

resolveRawArgument

public static Class<?> resolveRawArgument(Type genericType,
                                          Class<?> subType)

Returns the raw class representing the argument for the genericType using type variable information from the subType. If genericType is an instance of class, then genericType is returned. If no arguments can be resolved then Unknown.class is returned.

参数:

genericType - to resolve argument for

subType - to extract type variable information from

返回:

argument for genericType else TypeResolver.Unknown.class if no type arguments are declared

抛出:

IllegalArgumentException - if more or less than one argument is resolved for the genericType

resolveRawArguments

public static <T,S extends T> Class<?>[] resolveRawArguments(Class<T> type,
                                                             Class<S> subType)

Returns an array of raw classes representing arguments for the type using type variable information from the subType. Arguments for type that cannot be resolved are returned as Unknown.class. If no arguments can be resolved then null is returned.

参数:

type - to resolve arguments for

subType - to extract type variable information from

返回:

array of raw classes representing arguments for the type else null if no type arguments are declared

reify

public static <T,S extends T> Type reify(Class<T> type,
                                         Class<S> context)

Traverses a generic type and replaces all type variables and wildcard types with concrete types (if possible), by using the type information from given context. A convenience method which largely works the same as reify(Type, Class), but first resolves the generic type of type.

参数:

type - the class whose generic type to traverse

context - the class that serves as starting point to resolve replacements of type variables

返回:

a type that is structurally the same as type, except that type variables and wildcard types have been replaced with concrete types

抛出:

UnsupportedOperationException - if type (or a type that it references) is not an instance of one of the following types: Class, TypeVariable, WildcardType, ParameterizedType, GenericArrayType.

UnsupportedOperationException - if type (or a type that it references) is a WildcardType that does not have exactly one upper bound, or does not have no lower bounds.

UnsupportedOperationException - if type (or a type that it references) is a GenericArrayType whose generic component type cannot be reified to an instance of Class.

reify

public static Type reify(Type type,
                         Class<?> context)

Traverses a generic type and replaces all type variables and wildcard types with concrete types (if possible), by using the type information from given context.

Generic types used as input to this method are commonly obtained using reflection, e.g. via Field.getGenericType(), Method.getGenericReturnType(), Method.getGenericParameterTypes().

Example:

   class A<T> {
     public T something;
     public Optional<List<T>> compute() { ... }
   }

   class B extends A<Number> {
     public <? extends Collection<List<?>>> collect() { ... }
   }
 

Reifying the generic return type of the method compute with B.class as context will yield the parameterized type Optional<List<Number>>. Note that not the raw type (Optional is returned, but the input type is reified recursively. Reifying the generic type of the field something with B.class as context will yield Number.class.

Note that type variables with no explicit upper bound are reified to Object, and Unknown.class is never returned.

参数:

type - the generic type to traverse

context - the class that serves as starting point to resolve replacements of type variables

返回:

a type that is structurally the same as type, except that type variables and wildcard types have been replaced with concrete types

抛出:

UnsupportedOperationException - if type (or a type that it references) is not an instance of one of the following types: Class, TypeVariable, WildcardType, ParameterizedType, GenericArrayType.

UnsupportedOperationException - if type (or a type that it references) is a WildcardType that does not have exactly one upper bound, or does not have no lower bounds.

UnsupportedOperationException - if type (or a type that it references) is a GenericArrayType whose generic component type cannot be reified to an instance of Class.

reify

public static Type reify(Type type)

Traverses a generic type and replaces all type variables and wildcard types with concrete types (if possible). A convenience wrapper around reify(Type, Class), for when no context is needed/available.

Generic types used as input to this method are commonly obtained using reflection, e.g. via Field.getGenericType(), Method.getGenericReturnType(), Method.getGenericParameterTypes().

Example:

   class X {
     public List<? extends Collection<List<? extends Number>>> collectList() { ... }
     public Set<?> collectSet() { ... }
   }
 

Reifying the generic return type of the method collectList will yield the parameterized type List<Collection<List<Number>>>. Reifying the generic return type of the method collectSet will yield the parameterized type Set<Object>, since there is no explicit upper bound for the wildcard type given.

参数:

type - the generic type to traverse

返回:

a type that is structurally the same as type, except that type variables and wildcard types have been replaced with concrete types

抛出:

UnsupportedOperationException - if type (or a type that it references) is not an instance of one of the following types: Class, TypeVariable, WildcardType, ParameterizedType, GenericArrayType.

UnsupportedOperationException - if type (or a type that it references) is a WildcardType that does not have exactly one upper bound, or does not have no lower bounds.

UnsupportedOperationException - if type (or a type that it references) is a GenericArrayType whose generic component type cannot be reified to an instance of Class.

resolveRawArguments

public static Class<?>[] resolveRawArguments(Type genericType,
                                             Class<?> subType)

Returns an array of raw classes representing arguments for the genericType using type variable information from the subType. Arguments for genericType that cannot be resolved are returned as Unknown.class. If no arguments can be resolved then null is returned.

参数:

genericType - to resolve arguments for

subType - to extract type variable information from

返回:

array of raw classes representing arguments for the genericType else null if no type arguments are declared

resolveGenericType

public static Type resolveGenericType(Class<?> type,
                                      Type subType)

Returns the generic type using type variable information from the subType else null if the generic type cannot be resolved.

参数:

type - to resolve generic type for

subType - to extract type variable information from

返回:

generic type else null if it cannot be resolved

resolveRawClass

public static Class<?> resolveRawClass(Type genericType,
                                       Class<?> subType)

Resolves the raw class for the genericType, using the type variable information from the subType else TypeResolver.Unknown if the raw class cannot be resolved.

参数:

genericType - to resolve raw class for

subType - to extract type variable information from

返回:

raw class for the genericType else TypeResolver.Unknown if it cannot be resolved

resolveBound

public static Type resolveBound(TypeVariable<?> typeVariable)

Resolves the first bound for the typeVariable, returning Unknown.class if none can be resolved.